¿Cómo debo implementar Object.GetHashCode() para la igualdad compleja?

Question

Básicamente, tengo los siguientes hasta el momento:

class Foo { 
    public override bool Equals(object obj) 
    { 
     Foo d = obj as Foo ; 
     if (d == null) 
      return false; 

     return this.Equals(d); 
    } 

    #region IEquatable<Foo> Members 

    public bool Equals(Foo other) 
    { 
     if (this.Guid != String.Empty && this.Guid == other.Guid) 
      return true; 
     else if (this.Guid != String.Empty || other.Guid != String.Empty) 
      return false; 

     if (this.Title == other.Title && 
      this.PublishDate == other.PublishDate && 
      this.Description == other.Description) 
      return true; 

     return false; 
    } 
} 

Por lo tanto, el problema es el siguiente: Tengo un campo no requiere Guid, que es un identificador único. Si esto no está establecido, entonces debo tratar de determinar la igualdad basada en métricas menos precisas como un intento de determinar si dos objetos son iguales. Esto funciona bien, pero hace GetHashCode() desordenado ... ¿Cómo debo hacerlo? Una implementación ingenua sería algo así como:

public override int GetHashCode() { 
    if (this.Guid != String.Empty) 
     return this.Guid.GetHashCode(); 

    int hash = 37; 
    hash = hash * 23 + this.Title.GetHashCode(); 
    hash = hash * 23 + this.PublishDate.GetHashCode(); 
    hash = hash * 23 + this.Description.GetHashCode(); 
    return hash; 
} 

Pero ¿cuáles son las posibilidades de que los dos tipos de hash de la colisión? Ciertamente, no esperaría que fuera 1 in 2 ** 32. ¿Es esta una mala idea, y si es así, cómo debería hacerlo?

Answer 1

No creo que haya un problema con el enfoque que ha elegido usar. Preocuparse demasiado por las colisiones hash casi siempre es una indicación de pensar demasiado el problema; siempre que el hash sea muy probable que sea diferente, deberías estar bien.

En última instancia, es posible que desee considerar omitir el Description de su hash de todos modos si es razonable esperar que la mayoría de las veces los objetos se puedan distinguir en función de su título y fecha de publicación (¿libros?).

Incluso podría considerar ignorar por completo el GUID en su función de hash, y solo usarlo en la implementación Equals para eliminar la ambigüedad del improbable (?) Caso de choques de hash.

Answer 2

Un muy fácil hash code method for custom classes es a nivel de bit XOR cada uno de los códigos de campo códigos juntos. Puede ser tan simple como esto:

int hash = 0; 
hash ^= this.Title.GetHashCode(); 
hash ^= this.PublishDate.GetHashCode(); 
hash ^= this.Description.GetHashCode(); 
return hash; 

Desde el link above:

XOR tiene las siguientes propiedades agradables:

• que no depende de la orden de cómputo.
• No "desperdicia" bits. Si cambia incluso un bit en uno de los componentes, el valor final cambiará.
• Es rápido, un solo ciclo incluso en la computadora más primitiva.
• Conserva la distribución uniforme. Si las dos piezas que combinas están uniformemente distribuidas, así será la combinación. En otras palabras, no tiende a colapsar el rango del resumen en una banda más estrecha.

XOR no funciona bien si usted espera tener valores duplicados en sus campos como valores duplicados se anulan entre sí cuando XORed. Ya que has hashing juntos tres campos no relacionados que no deberían ser un problema en este caso.