Wie Sie feststellen, wenn zwei generische Typ-Werte gleich sind?

Dein code sieht gut aus. Das problem hier ist, dass die Klasse StringBuilder hat eine unübersichtliche Menge von gleich zu Gleich, die widersprüchlich sind. Insbesondere Equals ("StringBuilder") ist nicht einverstanden mit Equals(Objekt), selbst wenn das Objekt ist einen StringBuilder.

Alle, die EqualityComparer<T> muss ist eine vernünftige Equals(object) Implementierung. Die Schnittstelle (IEquatable<T>) ist optional. Leider StringBuilder nicht über diese (zumindest im Vergleich zu den "Equals" ("StringBuilder"), die Ihre Dritte test verwendet).

Aber im Allgemeinen, der Rat ist: verwenden Sie EqualityComparer<T>; dies unterstützt:

• nullable-von-T mit standard "gehoben" Regeln
• IEquatable-von-T
• Objekt.Gleich

Als Eric Lippert sagt, dass in Antwort auf diese Frage - Überlast Auflösung erfolgt zur compile-Zeit.

Wenn man einen Blick auf StringBuilder's Implementierung Sie werden feststellen, es überlastungen Equals und nicht überschrieben. Dies ist im Grunde die Wurzel des Problems, warum StringBuilder.Equals funktioniert nicht wie erwartet in Ihrem Beispiel.

Nehmen Sie die folgenden 2 Klassen als Beispiel. Overloader ist Analog zu StringBuilder im Beispiel, wie es überlastungen Equals. Overrider ist sehr ähnlich, außer er überschreibt es Equals statt.

public class Overloader
{
  public string Str {get;private set;}
  public Overloader (string str) {Str = str;}

  public bool Equals( Overloader str )
  {
    return this.Str.Equals( str );
  }
}

public class Overrider
{
  public string Str {get;private set;}
  public Overrider (string str) {Str = str;}

  public override bool Equals( object obj )
  {
    if ( obj is Overrider )
    {
      return this.Str.Equals( (obj as Overrider).Str );
    }
    return base.Equals( obj );
  }
}

Habe ich leicht modifiziert Ihre GenericObject<T> Klasse in meinem Beispiel:

class GenericOjbect<T>
{
  public T Value {get;private set;}
  public GenericOjbect( T val ) {Value = val;}

  public bool Equals( T val )
  {
    return Value.Equals( val );
  }

  public override bool Equals( object obj )
  {
    if ( obj is T )
    {
      return this.Equals( ( T )obj );
    }
    if (obj != null && obj is GenericOjbect<T> )
    {
      return this.Equals( ( obj as GenericOjbect<T> ).Value );
    }
    return base.Equals( obj );
  }
}

In diesem Beispielprogramm sehen Sie, dass Overloader (oder Stringbuilder für diese Angelegenheit) den Wert false zurück. Allerdings Overrider true zurück.

class Program
{
  static void Main( string[] args )
  {
    var goOverloader1 = new GenericOjbect<Overloader>( new Overloader( "StackOverflow" ) );
    var goOverloader2 = new GenericOjbect<Overloader>( new Overloader( "StackOverflow" ) );

    var goOverrider1 = new GenericOjbect<Overrider>( new Overrider( "StackOverflow" ) );
    var goOverrider2 = new GenericOjbect<Overrider>( new Overrider( "StackOverflow" ) );

    Console.WriteLine( "Overrider  : {0}", goOverloader1.Equals( goOverloader2 ) ); //False
    Console.WriteLine( "Overloader : {0}", goOverrider1.Equals( goOverrider2 ) ); //True
  }
}

Verweisen auf Eric Lippert wieder - Überlast Auflösung erfolgt zur compile-Zeit. Was bedeutet, dass der compiler im Grunde schaut auf Eure GenericObject<T>.Equals( T val ) wie diese:

public bool Equals( T val )
{
  return Value.Equals( (Object) val );
}

Anwser zu Ihrer Frage , Wie um zu bestimmen, wenn zwei generische Typ-Werte gleich sind?. Es gibt zwei Dinge, die Sie möglicherweise tun könnte.

1. Wenn Sie eigenen alle Objekte, eingewickelt in GenericObject<T> sicherzustellen, dass Sie alle mindestens überschreiben Equals.
2. Sie ausführen könnte einige Reflexion Magie in Ihrem GenericObject<T>.Equals(T val) manuell führen Sie die späte Bindung.

Können Sie entweder implementieren , IEquatable<T>, oder implementieren Sie einen comparer-Klasse, die , IEqualityComparer<T>.

Stellen Sie sicher, dass value Sie überprüfen die Gleichheit ist unveränderlich und wird nur bei der Initialisierung der Klasse.

Andere überlegung wäre die Umsetzung IComparer<T>, wenn Sie implementieren diese ein, werden Sie nicht haben, um sorgen über den hash-code, und damit umgesetzt werden kann, für veränderliche Typen/Felder als gut.

Sobald Sie richtig implementieren , IEquatable<T> in Ihrer Klasse, Ihre Fragen werden gelöst.

Update:
Aufruf return EqualityComparer<T>.Default.Equals(Value, value); würde grundsätzlich return gleichen Ergebnis, da es keine IEqualityComparer<T> umgesetzt...