Überschreiben Entspricht und vergleicht mit Zeichenfolge

Question

Ich habe eine C# -Klasse mit einem Zeichenfolgenelement definiert. Für alle Absichten ein Zweck, denke an diese Klasse als eine Unterklasse von String (außer das ist nicht erlaubt). Ich benutze es, um ein stark typisiertes Zeichenkettenfeld darzustellen, das einem bestimmten Format entspricht (ich habe es erheblich vereinfacht).

public class field 
{ 
    private readonly string m_field; 
    public field(string init_value) 
    { 
     //Check the syntax for errors 
     if (CheckSyntax(init_value)) 
     { 
      m_field = init_value; 
     } 
     else 
     { 
      throw new ArgumentOutOfRangeException(); 
     } 
    } 

    public override string ToString() 
    { 
     return m_field; 
    } 
} 

Nun, ich mag diese Klasse kann auf jede beliebige andere Zeichenfolge (Objekt oder wörtliche) direkt miteinander vergleichen. Deshalb habe ich die folgenden in der Klasse implementiert:

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

    return this.m_field == obj.ToString(); 
} 

public override int GetHashCode() 
{ 
    return this.m_field.GetHashCode(); 
} 

public static bool operator ==(field x, Object y) 
{ 
    if ((object)x == null && y == null) 
    { 
     return true; 
    } 
    else if ((object)x == null || y == null) 
    { 
     return false; 
    } 
    else 
    { 
     return (x.m_field == y.ToString()); 
    } 
} 

public static bool operator !=(field x, Object y) 
{ 
    return !(x == y); 
} 

Nun, wenn ich einen Komponententest ich schreibe, abhängig von der Reihenfolge, die ich in den Argumenten zu Assert.AreEqual bin vorbei, erhalte ich unterschiedliche Ergebnisse:

Ich nehme an, dies liegt daran, in der ersten Assert, ruft es field.Equals() und in der zweiten ruft es String.Equals(). Offensichtlich nähere ich mich dem aus dem falschen Winkel. Kann mir jemand einen Einblick geben?

Eine andere Sache. Ich kann hier keine Struktur (Werttyp) verwenden, da ich das in meinem tatsächlichen Fall in einer Basisklasse definiere und davon erben.

Answer 1

Dies ist im Detail in Effective Java als Artikel 8 beschrieben: Befolgen Sie die allgemeinen Vertrags wenn equals überschrieben.

Die Methode equals implementiert eine Äquivalenzrelation.

Es ist reflexiv, symmetrisch, Transitive, konsistent und für alle Nicht-NULL-Verweis x, x.equals(null) muss false zurück. Das genannte Beispiel, um die Symmetrie zu brechen, ist ähnlich wie bei Ihnen.

field Klasse ist sich dessen bewusst string Klasse, aber die eingebaute in string Klasse ist nicht bekannt, field. Dies ist eine einseitige Interoperabilität und sollte entfernt werden.

Answer 2

Grundsätzlich können Sie nicht tun, was Sie wollen - es gibt keine Möglichkeit, string Ihre Klasse für Gleichstellungszwecke zu erkennen. Sie werden es niemals reflexartig machen können - Sie werden es niemals in die Lage versetzen, dem Vertrag von object.Equals zu folgen.

Ich würde persönlich versuchen, es neu zu gestalten, so dass Sie nicht die Validierung als Teil des Typs selbst haben - machen Sie es Teil der relevanten Eigenschaften der Geschäftseinheiten (oder was auch immer sie sind).

Answer 3

würde ich jemand mit Ihrem Feldklasse implizit als String entmutigen, und zwingen diese Art der Nutzung:

string valid = "Some String"; 
field target = new field(valid); 
Assert.AreEqual(target.toString(), valid); 
Assert.AreEqual(valid, target.toString()); 

Answer 4

Basierend auf jeden Feedback und meine eigenen Bedürfnisse, hier ist was nach vorne als eine mögliche Lösung Ich stelle (Ich bin die Equals-Methode wie folgt zu ändern):

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

    field f = obj as field; 
    if (f != null) 
    { 
     return this == f; 
    } 
    else 
    { 
     return obj.Equals(this); 
    } 
} 

Dies scheint seine richtige zu ermöglichen Verwendung in Dictionary- und Auflistungsklassen, die auf den Equals- und GetHashCode-Methoden beruhen, um festzustellen, ob der Wert bereits vorhanden ist.

Auch jetzt diese beide fehlschlagen:

string valid = "Some String"; 
field target = new field(valid); 
Assert.AreEqual(target, valid); // FAILS 
Assert.AreEqual(valid, target); // FAILS 

Und diese beiden passieren:

string valid = "Some String"; 
field target = new field(valid); 
Assert.AreEqual(target.ToString(), valid); // PASSES 
Assert.AreEqual(valid, target.ToString()); // PASSES 

Und diese beiden passieren:

field f1 = new field("Some String"); 
field f2 = new field("Some String"); 
Assert.AreEqual(f1, f2); // PASSES 
Assert.AreEqual(f2, f1); // PASSES 

Answer 5

Dies ist String # Equals

public override bool Equals(object obj) 
{ 
    string strB = obj as string; 
    if ((strB == null) && (this != null)) 
    { 
     return false; 
    } 
    return EqualsHelper(this, strB); 
} 

Liefern eines anderen Arguments als String an String # Equals wird false zurückgeben. Ich würde ein "Umdenken" vorschlagen, um das zu umgehen.

Answer 6

Ich empfehle die Verwendung object.ReferenceEquals(), wenn Sie intern versuchen zu überprüfen, ob x oder y null ist.

public static bool operator ==(field x, Object y) 
{ 
    if (object.ReferenceEquals(x, null) && object.ReferenceEquals(y, null)) 
    { 
     return true; 
    } 
    else if (object.ReferenceEquals(x, null) || object.ReferenceEquals(y, null)) 
    { 
     return false; 
    } 
    else 
    { 
     return (x.m_field == y.ToString()); 
    } 
}