¿Por qué no podemos anular Equals() en un tipo de valor sin boxeo?

Question

Sé que puedo evitar el boxeo al agregar mi propia implementación Equals.

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 && m_Im == c.m_Im; 
    } 
} 

No puedo llamar esto tanto una sobrecarga como una sobrecarga. Por la magia del tiempo de ejecución, llama correctamente a la implementación correcta Equals() según el tipo de llamante.

¿Por qué no puedo anular y cambiar el tipo de parámetro a TwoDoubles y dejar que el boxeo se produzca con la potencia del tiempo de ejecución según sea necesario? ¿Es porque C# no admite la contravariancia del parámetro (si ese es el motivo, entonces, por qué no es compatible ... parece un pequeño paso desde object o = new TwoDoubles())?

ACTUALIZACIÓN
Aclaración: object es una parte de la jerarquía de herencia de una estructura. ¿Por qué no podemos especificar un tipo más derivado como parámetro para anular una implementación de un tipo menos derivado? Esto nos permitirá escribir:

public override bool Equals(TwoDoubles ob) 
{ 
     TwoDoubles c = ob; 
     return m_Re == c.m_Re && m_Im == c.m_Im;  
} 

que debería ser llamado cuando la variable es una TwoDouble incluso si dicha variable ha sido encasillados en un tipo de objeto.

Answer 1

¿Por qué no puedo anular y cambiar el tipo de parámetro a TwoDoubles?

¡Porque eso no sería seguro!

class B 
{ 
    public virtual void M(Animal animal) { ... } 
} 
class D : B 
{ 
    public override void M(Giraffe animal) { ... } 
} 

B b = new D(); 
b.M(new Tiger()); 

¡Y ahora acaba de pasar un tigre a un método que en realidad solo requiere una jirafa!

Lo mismo en su caso. Está anulando un método que toma cualquier objeto con un método que solo puede tomar una estructura; eso no es seguro.

¿Es debido a que C# no es compatible con el tipo de parámetro contravarianza?

No, es porque usted está pidiendo parámetro de tipo covarianza, que no es typesafe.

C# tampoco admite la contravariancia del tipo de parámetro, pero eso no es lo que está pidiendo.

Answer 2

Puede cambiar el parámetro (sobrecarga) durante Equals, tal y como lo ha hecho, y se realizarán boxeo como sea necesario (es decir, siempre Iguales (objeto) se llama)

Porque todo hereda (o implícitamente a través de boxeo) desde el objeto, no puede evitar que las personas puedan usar Equals (objeto) en su tipo. Sin embargo, al hacerlo, obtienes una llamada en caja.

Si usted está en control del código de llamada, a continuación, utilizar siempre su nueva opción de sobrecarga, es decir Equals(TwoDouble)

Tenga en cuenta, como uno commentor ya se ha dicho, su código es ligeramente incorrecto, debe hacerse lo siguiente:

public override bool Equals(object ob) 
{ 
    if (ob is TwoDoubles) 
    return Equals((TwoDoubles)ob); 
    else 
    return false; 
} 
public bool Equals(TwoDoubles c) 
{ 
    return m_Re == c.m_Re && m_Im == c.m_Im; 
} 

EDITAR como se ha sugerido sabiamente, se debe realizar esta misma tarea, pero mediante el uso de la interfaz IEquatable, en este caso IEquatable<TwoDouble> (nota, sin cambio de código necesaria de lo que hemos hecho, ya que coincide con la firma)

Answer 3

Si funcionó como sugirió, donde public override bool Equals(TwoDoubles c) { return m_Re == c.m_Re && m_Im == c.m_Im; } era todo lo que era necesario para anular el método Equals(object), ¿qué haría este código?

TwoDoubles td = new TwoDoubles(); 
object o = td; 
bool b = o.Equals(new object()); // Equals(object) overridden with Equals(TwoDouble) 

¿Qué debería pasar en la línea 3?

• ¿Debería llamar al Equals(TwoDouble)? Si es así, ¿con qué parámetro? ¿Un TwoDouble predeterminado con todos los ceros? Eso violaría las reglas que rodean la igualdad.
• ¿Debería lanzar una excepción de cast? Seguimos la firma del método correctamente, así que eso no debería suceder.
• ¿Debería devolver siempre falso? Ahora el compilador tiene que ser consciente de que el método Equal significa, y tendrá que tratarlo de manera diferente a otros métodos.

No hay una buena manera de implementar esto, y rápidamente causa más problemas de los que resuelve.