Distinct() devuelve duplicados con un tipo definido por el usuario

Question

Estoy tratando de escribir una consulta Linq que devuelve una matriz de objetos, con valores únicos en sus constructores. Para los tipos enteros, Distinct devuelve solo una copia de cada valor, pero cuando intento crear mi lista de objetos, las cosas se desmoronan. Sospecho que es un problema con el operador de igualdad para mi clase, pero cuando configuro un punto de interrupción, nunca se golpea.

Al filtrar el duplicado int en una subexpresión resuelve el problema, y ​​también me ahorra la construcción de objetos que se descartarán inmediatamente, pero me llama la atención por qué esta versión no funciona.

ACTUALIZACIÓN: 11:04 PM Varias personas han señalado que MyType no anula GetHashCode(). Me temo que simplifiqué demasiado el ejemplo. El MyType original sí lo implementa. Lo he agregado a continuación, modificado solo para poner el código hash en una variable temp antes de devolverlo.

Ejecutando a través del depurador, veo que las cinco invocaciones de GetHashCode devuelven un valor diferente. Y como MyType solo hereda de Object, es probable que este sea el mismo comportamiento que Object exhibiría.

¿Sería correcto concluir que el hash debería basarse en los contenidos de Value? Este fue mi primer intento de anular a los operadores, y en ese momento, no parecía que GetHashCode tuviera que ser particularmente elegante. (Esta es la primera vez que uno de mis cheques de igualdad no parecía funcionar correctamente.)

class Program 
{ 
    static void Main(string[] args) 
    { 
     int[] list = { 1, 3, 4, 4, 5 }; 
     int[] list2 = 
      (from value in list 
      select value).Distinct().ToArray(); // One copy of each value. 
     MyType[] distinct = 
      (from value in list 
      select new MyType(value)).Distinct().ToArray(); // Two objects created with 4. 

     Array.ForEach(distinct, value => Console.WriteLine(value)); 
    } 
} 

class MyType 
{ 
    public int Value { get; private set; } 

    public MyType(int arg) 
    { 
     Value = arg; 
    } 

    public override int GetHashCode() 
    { 
     int retval = base.GetHashCode(); 
     return retval; 
    } 

    public override bool Equals(object obj) 
    { 
     if (obj == null) 
      return false; 

     MyType rhs = obj as MyType; 
     if ((Object)rhs == null) 
      return false; 

     return this == rhs; 
    } 

    public static bool operator ==(MyType lhs, MyType rhs) 
    { 
     bool result; 

     if ((Object)lhs != null && (Object)rhs != null) 
      result = lhs.Value == rhs.Value; 
     else 
      result = (Object)lhs == (Object)rhs; 

     return result; 
    } 

    public static bool operator !=(MyType lhs, MyType rhs) 
    { 
     return !(lhs == rhs); 
    } 
} 

Answer 1

Debe anular GetHashCode() en su clase. GetHashCode debe implementarse en tándem con sobrecargas iguales. Es común que el código verifique la igualdad del código hash antes de llamar a Equals. Es por eso que su implementación Equals no recibe una llamada.

Answer 2

Su sospecha es correcta, es la igualdad que en la actualidad se limita a comprobar las referencias a objetos. Incluso su aplicación no hace nada extra, cambiarlo a esto:

public override bool Equals(object obj) 
{ 
    if (obj == null) 
     return false; 

    MyType rhs = obj as MyType; 
    if ((Object)rhs == null) 
     return false; 

    return this.Value == rhs.Value; 
} 

Answer 3

creo MyType necesita implementar IEquatable para que esto funcione.

Answer 4

En ti método de la igualdad todavía están probando para la igualdad de referencia, en lugar de la igualdad semántica, por ejemplo en esta línea:

result = (Object)lhs == (Object)rhs 

que sólo está comparando dos referencias a objetos que, aunque se mantienen exactamente los mismos datos , todavía no son el mismo objeto. En cambio, su prueba de igualdad necesita comparar una o más propiedades de su objeto. Por ejemplo, si el objeto tenía una propiedad ID y objetos con el mismo ID debe considerarse semánticamente equivalentes, entonces se podría hacer esto:

result = lhs.ID == rhs.ID 

Tenga en cuenta que anulando equals() significa que también debe reemplazar GetHashCode() , que es otra olla de pescado, y puede ser bastante difícil de hacer correctamente.

Answer 5

Debe implementar GetHashCode().

Answer 6

Las otras respuestas han cubierto más o menos el hecho de que es necesario implementar correctamente iguales y GetHashCode, pero como un lado Nota Es posible que le interese saber que los tipos anónimos han estos valores en práctica de forma automática:

var distinct = 
     (from value in list 
     select new {Value = value}).Distinct().ToArray(); 

Entonces, sin tener que definir esta clase, automáticamente obtienes el comportamiento Equals y GetHashCode que estás buscando. Genial, ¿eh?

Answer 7

Parece que una simple operación de Distinct puede ser implementado más elegante como sigue:

var distinct = items.GroupBy(x => x.ID).Select(x => x.First()); 

donde ID es la propiedad que determina si dos objetos son semánticamente equivalente. A partir de la confusión aquí (incluida la de mí mismo), la implementación predeterminada de Distinct() parece ser un poco intrincada.