title: Why cant we override Equals() in a value type without boxing?
body: <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>