Distinct() restituisce i duplicati con un tipo definito dall'utente

Question

Sto provando a scrivere una query Linq che restituisce una matrice di oggetti, con valori univoci nei relativi costruttori. Per i tipi interi, Distinct restituisce solo una copia di ciascun valore, ma quando provo a creare il mio elenco di oggetti, le cose vanno in pezzi. Sospetto che sia un problema con l'operatore di uguaglianza per la mia classe, ma quando imposto un breakpoint non viene mai colpito.

Il filtraggio del duplicato int in una sottoespressione risolve il problema, inoltre mi salva dalla creazione di oggetti che verranno immediatamente eliminati, ma sono curioso del perché questa versione non funzioni.

AGGIORNAMENTO: 11:04 PM Diverse persone hanno sottolineato che MyType non sovrascrive GetHashCode(). Temo di aver semplificato eccessivamente l'esempio. Il MyType originale lo implementa davvero. L'ho aggiunto di seguito, modificato solo per inserire il codice hash in una variabile temporanea prima di restituirlo.

Eseguendo il debugger, vedo che tutte e cinque le invocazioni di GetHashCode restituiscono un valore diverso. E poiché MyType eredita solo da Object, questo è presumibilmente lo stesso comportamento che l'oggetto mostrerebbe.

Sarei corretto quindi per concludere che l'hash dovrebbe invece essere basato sul contenuto di Valore? Questo è stato il mio primo tentativo di scavalcare gli operatori e, al momento, non sembrava che il codice GetHash fosse particolarmente elaborato. (Questa è la prima volta che uno dei miei assegni di uguaglianza non sembra funzionare correttamente.)

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

È necessario eseguire l'override di GetHashCode() nella classe. GetHashCode deve essere implementato in tandem con sovraccarichi Equals. È normale che il codice controlli l'uguaglianza di hashcode prima di chiamare Equals. Ecco perché la tua implementazione di Equals non viene chiamata.

Answer 2

tuo sospetto è corretto, è l'uguaglianza che attualmente solo controlla i riferimenti agli oggetti. Anche l'implementazione non fa nulla in più, modificarlo a questo:

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

penso MyType deve attuare IEquatable per far funzionare tutto questo.

Answer 4

In te metodo di uguaglianza si sta ancora testando per l'uguaglianza di riferimento, piuttosto che l'uguaglianza semantica, ad esempio, su questa linea:

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

si sono appena confrontano due riferimenti a oggetti che, anche se in loro possesso esattamente gli stessi dati , non sono ancora lo stesso oggetto. Invece, il test per l'uguaglianza deve confrontare una o più proprietà del tuo oggetto. Per esempio, se l'oggetto aveva una proprietà ID, e gli oggetti con lo stesso ID dovrebbe essere considerato semanticamente equivalenti, allora si potrebbe fare questo:

result = lhs.ID == rhs.ID 

Si noti che l'override equals() significa che si dovrebbe anche ignorare GetHashCode() , che è un altro bollitore di pesce, e può essere abbastanza difficile da fare correttamente.

Answer 5

È necessario implementare GetHashCode().

Answer 6

Le altre risposte hanno praticamente coperto il fatto che è necessario implementare correttamente Equals e GetHashCode, ma come un lato Nota Potrebbe essere interessati a sapere che tipi anonimi sono questi valori implementato automaticamente:

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

Quindi, senza dover definire questa classe, ottieni automaticamente il comportamento di Equals e GetHashCode che stai cercando. Fantastico, eh?

Answer 7

Sembra che una semplice operazione Distinct può essere implementato più elegantemente come segue:

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

dove ID è la proprietà che determina se due oggetti sono semanticamente equivalenti. Dalla confusione qui (incluso quella di me stesso), l'implementazione di default di Distinct() sembra essere un po 'contorta.