Why cant we override Equals() in a value type without boxing?
<p>I know I can avoid boxing by adding my own Equals implementation.</p>

<pre><code>public struct TwoDoubles
{
    public double m_Re;
    public double m_Im;

    public TwoDoubles(double one, double two)
    {
        m_Re = one;
        m_Im = two;
    }

    public override bool Equals(object ob)
    {
           return Equals((TwoDoubles)ob);
    }
    public bool Equals(TwoDoubles ob)
    {
        TwoDoubles c = ob;
        return m_Re == c.m_Re &amp;&amp; m_Im == c.m_Im;
    }
}
</code></pre>

<p>I can't call this an override as much as an overload.  By the magic of the runtime it does correctly call the correct <code>Equals()</code> implementation based on the type of the caller.</p>

<p>Why can't I override and change the parameter type to <code>TwoDoubles</code> and let boxing occur by the power of the runtime on an as needed basis?  Is it because C# doesn't support parameter contravariance (if that's the reason then why is it not supported...seems a small step from <code>object o = new TwoDoubles()</code>)?  </p>

<p><strong>UPDATE</strong><br />
Clarification:  <code>object</code> is a part of the inheritance hierarchy of a struct.  Why can we not specify a more derived type as a parameter to override an implementation from a less derived type?  This would allow us to write:</p>

<pre><code> public override bool Equals(TwoDoubles ob)
 {
        TwoDoubles c = ob;
        return m_Re == c.m_Re &amp;&amp; m_Im == c.m_Im;    
 }
</code></pre>

<p>Which should be called when the variable is a TwoDouble even if said variable has been boxed into an object type.</p>
