Operador sobrecarga == versus Igual()

Question

Estoy trabajando en un proyecto C# en el que, hasta ahora, he usado objetos y fábricas inmutables para asegurar que los objetos de tipo Foo siempre se puedan comparar por igualdad con ==.

Foo los objetos no se pueden cambiar una vez creados, y la fábrica siempre devuelve el mismo objeto para un conjunto determinado de argumentos. Esto funciona muy bien, y en toda la base de código suponemos que == siempre funciona para verificar la igualdad.

Ahora necesito agregar algunas funcionalidades que presenten un caso de borde para el que esto no siempre funcionará. Lo más fácil es sobrecargar operator == para ese tipo, de modo que ninguno de los otros códigos en el proyecto necesite cambiar. Pero esto me parece un olor a código: sobrecargar operator == y no Equals me parece extraño, y estoy acostumbrado a la convención de que == comprueba la igualdad de referencia, y Equals comprueba la igualdad de objeto (o cualquiera que sea el término).

¿Es esto una preocupación legítima, o debería seguir adelante y sobrecargar operator ==?

Answer 1

Creo que el estándar es que para la mayoría de los tipos, .Equals verifica la similitud de los objetos, y el operador == comprueba la igualdad de referencia.

Creo que la mejor práctica es que para los tipos inmutables, el operador == debe verificar la similitud, así como .Equals. Y si quiere saber si realmente son el mismo objeto, use .ReferenceEquals. Consulte la clase C# String para ver un ejemplo de esto.

Answer 2

Para tipos inmutables, no creo que haya nada de malo en tener == sobrecargado para soportar la igualdad de valores. No creo que anule == sin anular Equals para tener la misma semántica. Si sobrescribe == y necesita verificar la igualdad de referencia por alguna razón, puede usar Object.ReferenceEquals(a,b).

ver este Microsoft article for some useful guidelines

Answer 3

Definitivamente huele. Al sobrecargar ==, debe asegurarse de que tanto Equals() como GetHashCode() también sean consistentes. Ver el MSDN guidelines.

Y la única razón por la que esto parece correcto es porque usted describe su tipo como inmutable.

Answer 4

Hay una gran diferencia entre sobrecarga== y anulando iguales.

Cuando se tiene la expresión

if (x == y) { 

El método que se utilizó para comparar variables x e y se decide en compilar tiempo. Esta es la sobrecarga del operador. El tipo utilizado al declarar xey se usa para definir qué método se usa para compararlos. El tipo real dentro de x y y (es decir, una subclase o implementación de interfaz) es irrelevante. Considera lo siguiente.

object x = "hello"; 
object y = 'h' + "ello"; // ensure it's a different reference 

if (x == y) { // evaluates to FALSE 

y la siguiente

string x = "hello"; 
string y = 'h' + "ello"; // ensure it's a different reference 

if (x == y) { // evaluates to TRUE 

Esto demuestra que el tipo utiliza para declarar las variables x e y se utiliza para determinar qué método se utiliza para evaluar ==.

En comparación, Equals se determina en runtime basado en el tipo real dentro de la variable x. Equals es un método virtual en Object que otros tipos pueden, y lo hacen, anular. Por lo tanto, los dos ejemplos siguientes se evalúan como verdaderos.

object x = "hello"; 
object y = 'h' + "ello"; // ensure it's a different reference 

if (x.Equals(y)) { // evaluates to TRUE 

y la siguiente

string x = "hello"; 
string y = 'h' + "ello"; // ensure it's a different reference 

if (x.Equals(y)) { // also evaluates to TRUE 

Answer 5

Microsoft de acuerdo con el propietario de Best prácticas del resultado del método Equals y los iguales (==) de sobrecarga debe ser el mismo.

CA2224: Override equals on overloading operator equals

Answer 6

ejemplo que muestra cómo implementar esta de acuerdo con MSFT guidelines (abajo). Tenga en cuenta que cuando anule Igual también debe anular GetHashCode(). Espero que esto ayude a la gente.

public class Person 
{ 
    public Guid Id { get; private set; } 

    public Person(Guid id) 
    { 
     Id = id; 
    } 

    public Person() 
    { 
     Id = System.Guid.NewGuid(); 
    } 

    public static bool operator ==(Person p1, Person p2) 
    { 
     bool rc; 

     if (System.Object.ReferenceEquals(p1, p2)) 
     { 
      rc = true; 
     } 
     else if (((object)p1 == null) || ((object)p2 == null)) 
     { 
      rc = false; 
     } 
     else 
     { 
      rc = (p1.Id.CompareTo(p2.Id) == 0); 
     } 

     return rc; 
    } 

    public static bool operator !=(Person p1, Person p2) 
    { 
     return !(p1 == p2); 
    } 

    public override bool Equals(object obj) 
    { 
     bool rc = false; 
     if (obj is Person) 
     { 
      Person p2 = obj as Person; 
      rc = (this == p2); 
     } 
     return rc; 
    } 

    public override int GetHashCode() 
    { 
     return Id.GetHashCode(); 
    } 
}