Meu entendimento é que você normalmente deveria usar xor com GetHashCode () para produzir um int para identificar seus dados por seu valor (em oposição a sua referência). Aqui está um exemplo simples:

<code>class Foo
{
    int m_a;
    int m_b;

    public int A
    {
        get { return m_a; }
        set { m_a = value; }
    }

    public int B
    {
        get { return m_b; }
        set { m_b = value; }
    }

    public Foo(int a, int b)
    {
        m_a = a;
        m_b = b;
    }

    public override int GetHashCode()
    {
        return A ^ B;
    }

    public override bool Equals(object obj)
    {
        return this.GetHashCode() == obj.GetHashCode();
    }
}
</code>

A idéia é, eu quero comparar uma instância de Foo para outro com base no valor das propriedades A e B. Se Foo1.A == Foo2.A e Foo1.B == Foo2.B, então temos igualdade.

Aqui está o problema:

<code>Foo one = new Foo(1, 2);
Foo two = new Foo(2, 1);

if (one.Equals(two)) { ... }  // This is true!
</code>

Ambos produzem um valor de 3 para GetHashCode (), fazendo com que Equals () retorne true. Obviamente, este é um exemplo trivial, e com apenas duas propriedades eu poderia simplesmente comparar as propriedades individuais no método Equals (). No entanto, com uma classe mais complexa, isso sairia de controle rapidamente.

Eu sei que às vezes faz sentido definir o código hash apenas uma vez e sempre retornar o mesmo valor. No entanto, para objetos mutáveis ​​em que uma avaliação de igualdade é necessária, não acho que isso seja razoável.

Qual é a melhor maneira de lidar com valores de propriedade que poderiam ser facilmente trocados ao implementar GetHashCode ()?

Veja também

Qual é o melhor algoritmo para um System.Object.GetHashCode substituído?