IComparable y equals()

Question

De MSDN

Tipos que implementen IComparable debe invalidar Equals.Types que sobrescribir equals también tendrá prioridad sobre GetHashCode; de lo contrario, Hashtable podría no funcionar correctamente.

No lo entendí del todo. ¿Alguien puede explicarlo?

Answer 1

IComparable es una interfaz que define que dos instancias de la clase implementadora se pueden ver como superiores, inferiores o iguales entre sí. Como ha definido la igualdad en los métodos de esa interfaz, también debe anular el método Equals (y el operador de igualdad) para garantizar que los resultados de los dos sean coherentes.

public class EqualityTest : IComparable<EqualityTest> 
{ 
     public int Value { get; set; } 

     public int CompareTo(EqualityTest other) 
     { 
      return this.Value.CompareTo(other.Value); 
     } 
} 

En el ejemplo anterior he implementado IComparable, pero no se reemplaza Igual. Si llama a CompareTo con dos instancias separadas de la clase que tienen el mismo valor, dirá que hay iguales. Si llama a Equals con las mismas dos instancias, dirá que son y no igual que probará para ver si son el mismo objeto (la implementación predeterminada de Equals).

dos artículos iguales deben devolver el mismo código hash (que se utiliza para encontrar rápidamente los elementos utilizados como claves en las tablas hash) por lo que si se reemplaza es igual, entonces también deberían anular GetHashCode()

---

Como ejemplo que acabo de crear la siguiente clase en mi IDE:

public class EqualityTest 
{ 
    public string A { get; set; } 
    public string B { get; set; } 
} 

y corrió función útil "Generar igualdad" de ReSharper diciendo que quería tanto a como B para afectar a la igualdad. Este es el código que creó:

public bool Equals(EqualityTest other) 
    { 
     if (ReferenceEquals(null, other)) 
     { 
      return false; 
     } 

     if (ReferenceEquals(this, other)) 
     { 
      return true; 
     } 

     return Equals(other.A, A) && Equals(other.B, B); 
    } 

    public override bool Equals(object obj) 
    { 
     if (ReferenceEquals(null, obj)) 
     { 
      return false; 
     } 

     if (ReferenceEquals(this, obj)) 
     { 
      return true; 
     } 

     if (obj.GetType() != typeof(EqualityTest)) 
     { 
      return false; 
     } 

     return Equals((EqualityTest)obj); 
    } 

    public override int GetHashCode() 
    { 
     unchecked 
     { 
      return ((A != null ? A.GetHashCode() : 0)*397)^(B != null ? B.GetHashCode() : 0); 
     } 
    } 

    public static bool operator ==(EqualityTest left, EqualityTest right) 
    { 
     return Equals(left, right); 
    } 

    public static bool operator !=(EqualityTest left, EqualityTest right) 
    { 
     return !Equals(left, right); 
    } 

Así que si está sustituyendo Igual entonces también debe definir todo lo anterior para garantizar la coherencia, si está implementando IComparable continuación, lo mismo se aplica.

Answer 2

Hay dos formas de que los objetos en el código podrían ser comparados: Equals y GetHashCode

Para su objeto a comparar adecuadamente en todas las situaciones, cuando se anula el Equals método (utilizado para algunas comparaciones), debe también anula GetHashCode (usado en el resto).

Si invalida una pero no la otra, según su código, podría obtener resultados inesperados.

Answer 3

IComparable se utiliza para comparar dos objetos. Si se consideran iguales, Compare devolverá 0. Sería muy inesperado si IComparable.Compare devolviera cero para dos objetos, pero obj1.Equals (obj2) devolvió el valor falso, ya que esto implica dos significados diferentes de igualdad para los objetos.

Cuando una clase anula Equals, también debe anular GetHashCode, ya que dos objetos iguales deben hash con el mismo valor, y este hash debe basarse en los campos/propiedades utilizados en la implementación de igualdad.