¿Cuál es la "mejor" implementación canónica de Equals() para los tipos de referencia?

Question

La implementación de Igual() para los tipos de referencia es más difícil de lo que parece. Mi aplicación canónica actual es la siguiente:

public bool Equals(MyClass obj) 
{ 
    // If both refer to the same reference they are equal. 
    if(ReferenceEquals(obj, this)) 
    return true; 

    // If the other object is null they are not equal because in C# this cannot be null. 
    if(ReferenceEquals(obj, null)) 
    return false; 

    // Compare data to evaluate equality  
    return _data.Equals(obj._data); 
} 

public override bool Equals(object obj) 
{ 
    // If both refer to the same reference they are equal. 
    if(ReferenceEquals(obj, this)) 
    return true; 

    // If the other object is null or is of a different types the objects are not equal. 
    if(ReferenceEquals(obj, null) || obj.GetType() != GetType()) 
    return false; 

    // Use type-safe equality comparison 
    return Equals((MyClass)obj); 
} 

public override int GetHashCode() 
{ 
    // Use data's hash code as our hashcode 
    return _data.GetHashCode(); 
} 

creo que esto cubre toda la esquina (herencia y tales casos), pero puedo estar equivocado. ¿Qué piensan ustedes?

Answer 1

Escribí una guía bastante completa de esto hace un tiempo. Para empezar, las implementaciones iguales deben compartirse (es decir, la sobrecarga que toma un objeto debe pasar a la que toma un objeto fuertemente tipado). Además, debe considerar cosas tales como que su objeto debe ser inmutable debido a la necesidad de anular GetHashCode. Más información aquí:

http://gregbeech.com/blog/implementing-object-equality-in-dotnet

Answer 2

Depende de si está escribiendo un tipo de valor o un tipo de referencia. Para un tipo de valor ordenable, lo recomiendo: A code snippet for Visual Studio 2005 that implements a skeleton value type adhering to Framework Design Guidelines

Answer 3

En cuanto a la herencia, creo que debería dejar que el paradigma OO haga su magia.

En concreto, se debe eliminar la comprobación GetType(), ya que podría romper el polimorfismo más adelante.

Answer 4

Estoy de acuerdo con chakrit, los objetos de diferentes tipos deben ser semánticamente iguales si tienen los mismos datos o ID.

Personalmente, yo uso el siguiente:

public override bool Equals(object obj) 
    { 
     var other = obj as MyClass; 
     if (other == null) return false; 

     return this.data.Equals(other.data); 
    } 

Answer 5

mejor esperanza de que this._data no es nulo si también es un tipo de referencia.

public bool Equals(MyClass obj) 
{ 
    if (obj == null) { 
     return false; 
    } 
    else { 
     return (this._data != null && this._data.Equals(obj._data)) 
         || obj._data == null; 
    } 
} 

public override bool Equals(object obj) 
{ 
    if (obj == null || !(obj is MyClass)) { 
     return false; 
    } 
    else { 
     return this.Equals((MyClass)obj); 
    } 
} 

public override int GetHashCode() { 
    return this._data == null ? 0 : this._data.GetHashCode(); 
}