EqualityComparer & lt; T & gt; .Default vs. T.Equals

Angenommen, ich habe eine generische MyClass<T> muss zum vergleichen von zwei Objekten des Typs <T>. Normalerweise würde ich so etwas tun ...

void DoSomething(T o1, T o2)
{
  if(o1.Equals(o2))
  {
    ...
  }
}

Nehmen wir nun an meine MyClass<T> hat einen Konstruktor, der unterstützt das übergeben eines benutzerdefinierten IEqualityComparer<T> ähnlich Dictionary<T>. In diesem Fall würde ich tun müssen ...

private IEqualityComparer<T> _comparer;
public MyClass() {}
public MyClass(IEqualityComparer<T> comparer)
{
  _comparer = comparer;
}
void DoSomething(T o1, T o2)
{
  if((_comparer != null && _comparer.Equals(o1, o2)) || (o1.Equals(o2)))
  {
    ...
  }
}

Entfernen diese lange if-Anweisung, es wäre gut, wenn ich könnte _comparer standardmäßig ein 'Standard-Programm', wenn die normalen Konstruktor verwendet wird. Ich suchte nach etwas, wie typeof(T).GetDefaultComparer() aber nicht in der Lage war zu finden, alles wie es.

Habe ich EqualityComparer<T>.Defaultkönnte ich nutzen? Und würde dann dieses snippet ...

public MyClass()
{
  _comparer = EqualityComparer<T>.Default;
}
void DoSomething(T o1, T o2)
{
  if(_comparer.Equals(o1, o2))
  {
    ...
  }
}

... liefern die gleichen Ergebnisse wie die Verwendung o1.Equals(o2) für alle möglichen Fälle?

(Wie sehen a side note, würde es bedeuten, ich würde auch brauchen, um irgendwelche spezielle generische Einschränkung für <T>?)

InformationsquelleAutor der Frage takrl | 2011-05-02

  1. 37

    Es sollten die gleichen sein, aber es ist nicht garantiert, denn Sie hängt von details der Implementierung der Typ T.

    Erklärung:

    Ohne eine Einschränkung zu T, o1.Equals(o2) ruft Object.Equals, auch wenn T implementiert IEquatable<T>.

    EqualityComparer<T>.Default jedoch Object.Equals nur, wenn T nicht umsetzen IEquatable<T>. Wenn es hat implementieren, die Schnittstelle, verwendet es IEquatable<T>.Equals.

    Solange T's Umsetzung von Object.Equals nur Anrufe IEquatable<T>.Equals das Ergebnis ist das gleiche. Aber das folgende Beispiel, das Ergebnis ist nicht das gleiche: 

    public class MyObject : IEquatable<MyObject>
{
    public int ID {get;set;}
    public string Name {get;set;}

    public override bool Equals(object o)
    {
        var other = o as MyObject;
        return other == null ? false : other.ID == ID;
    }    

    public bool Equals(MyObject o)
    {
        return o.Name == Name;
    } 
}

    Nun, es macht keinen Sinn, implementieren Sie eine Klasse wie dieses. Aber Sie haben das gleiche problem, wenn die Durchführung der MyObject einfach vergessen, Sie zu überschreiben Object.Equals.

    Fazit:

    Mit EqualityComparer<T>.Default ist ein guter Weg zu gehen, weil Sie nicht brauchen, um Unterstützung buggy-Objekte!

    InformationsquelleAutor der Antwort Daniel Hilgarth

  2. 3

    Standardmäßig bis überschreiben in einer Klasse Object.Equals(a,b)/a.Equals(b) führt einen Vergleich von Referenz.

    Was comparer zurückgegeben werden, indem EqualityComparer<T>.Default hängt T. Zum Beispiel, wenn T : IEquatable<> dann die entsprechenden EqualityComparer<T> erstellt werden.

    InformationsquelleAutor der Antwort abatishchev

  3. 2

    Könnten Sie die null-coaelescense Betreiber ?? zu verkürzen, die, wenn es wirklich wichtig ist

      if ((_comparer ?? EqualityComparer<T>.Default).Equals(o1, o2))
  {

  }

    InformationsquelleAutor der Antwort Marino Šimić

  4. 2

    Ja, ich denke, es wäre sinnvoll, die EqualityComparer<T>.Defaultdenn er nutzt die Umsetzung von IEquatable<T> wenn der Typ T implementiert, oder das überschreiben von Object.Equals sonst. Sie könnten das wie folgt:

    private IEqualityComparer<T> _comparer;
public IEqualityComparer<T> Comparer
{
    get { return _comparer?? EqualityComparer<T>.Default;}
    set { _comparer=value;}
}
public MyClass(IEqualityComparer<T> comparer)
{  
    _comparer = comparer;
}
void DoSomething(T o1, T o2)
{  
    if(Comparer.Equals(o1, o2))
    {
     ...
    }
}

    InformationsquelleAutor der Antwort AbdouMoumen

  5. 2

    Das ist genau das, was Dictionary<> und andere generische Sammlungen in der BCL tun, wenn Sie nicht geben Sie einen comparer bei der Konstruktion des Objekts. Der Vorteil dabei ist, dass EqualityComparer<T>.Default wird wieder das richtige Programm für IEquatable<T> - Typen nullable-Typen und enums. Wenn T ist keiner von denen, die es tun, ein einfaches ist-Gleich-Vergleich, wie man alten code macht.

    InformationsquelleAutor der Antwort Ryan Hauert

Schreibe einen Kommentar