Was ist die "beste" kanonische Implementierung von Equals() für Referenztypen?

Question

Die Implementierung von Equals() für Referenztypen ist schwieriger als es scheint. Meine aktuelle kanonische Implementierung geht so:

public bool Equals(MyClass obj) 
{ 
    // If both refer to the same reference they are equal. 
    if(ReferenceEquals(obj, this)) 
    return true; 

    // If the other object is null they are not equal because in C# this cannot be null. 
    if(ReferenceEquals(obj, null)) 
    return false; 

    // Compare data to evaluate equality  
    return _data.Equals(obj._data); 
} 

public override bool Equals(object obj) 
{ 
    // If both refer to the same reference they are equal. 
    if(ReferenceEquals(obj, this)) 
    return true; 

    // If the other object is null or is of a different types the objects are not equal. 
    if(ReferenceEquals(obj, null) || obj.GetType() != GetType()) 
    return false; 

    // Use type-safe equality comparison 
    return Equals((MyClass)obj); 
} 

public override int GetHashCode() 
{ 
    // Use data's hash code as our hashcode 
    return _data.GetHashCode(); 
} 

Ich glaube, das gilt für alle Ecke (Vererbung und so weiter) Fälle, aber ich kann falsch sein. Was denkt ihr?

Answer 1

Ich schrieb eine ziemlich umfassende Anleitung zu diesem eine Weile zurück. Für einen Anfang sollten Ihre equals-Implementierungen geteilt werden (d. H. Die Überladung, die ein Objekt nimmt, sollte zu dem passieren, der ein stark typisiertes Objekt aufnimmt). Darüber hinaus müssen Sie Dinge berücksichtigen, z. B. dass Ihr Objekt unveränderbar sein sollte, da GetHashCode überschrieben werden muss. Mehr Infos hier:

http://gregbeech.com/blog/implementing-object-equality-in-dotnet

Answer 2

Es hängt davon ab, ob Sie einen Werttyp oder einen Referenztyp schreiben. Für einen sortierbaren Werttyp empfehle ich Folgendes: A code snippet for Visual Studio 2005 that implements a skeleton value type adhering to Framework Design Guidelines

Answer 3

In Bezug auf die Vererbung denke ich, dass Sie das OO-Paradigma einfach magisch wirken lassen sollten.

Insbesondere sollte die GetType() Prüfung entfernt werden, könnte es Polymorphismus auf der ganzen Linie brechen.

Answer 4

Ich stimme Chakrit zu, Objekte unterschiedlicher Typen sollten semantisch gleich sein, wenn sie die gleichen Daten oder ID haben.

Persönlich benutze ich folgendes:

public override bool Equals(object obj) 
    { 
     var other = obj as MyClass; 
     if (other == null) return false; 

     return this.data.Equals(other.data); 
    } 

Answer 5

Bessere Hoffnung, dass this._data nicht null ist, wenn es auch ein Referenztyp.

public bool Equals(MyClass obj) 
{ 
    if (obj == null) { 
     return false; 
    } 
    else { 
     return (this._data != null && this._data.Equals(obj._data)) 
         || obj._data == null; 
    } 
} 

public override bool Equals(object obj) 
{ 
    if (obj == null || !(obj is MyClass)) { 
     return false; 
    } 
    else { 
     return this.Equals((MyClass)obj); 
    } 
} 

public override int GetHashCode() { 
    return this._data == null ? 0 : this._data.GetHashCode(); 
}