Kann nicht Operator == auf generische Typen in C# angewendet werden?

Question

Gemäß der Dokumentation des == Operator in MSDN,

Bei vordefinierten Wertetypen, die Gleichheitsoperator (==) liefert true, wenn die Werte der Operanden gleich sind, andernfalls false. Bei Referenztypen anders als string, gibt == true zurück, wenn seine beiden Operanden auf dasselbe Objekt verweisen. Beim String-Typ vergleicht == die Werte der Strings. Benutzerdefinierte Werttypen können den Operator == überladen (siehe Operator). So können benutzerdefinierte Referenztypen, obwohl standardmäßig == verhält sich wie oben beschrieben für beide vordefinierte und benutzerdefinierte Referenztypen.

Warum kann dieses Code-Snippet nicht kompiliert werden?

void Compare<T>(T x, T y) { return x == y; } 

erhalte ich die Fehler Operator '==' kann nicht auf Operanden vom Typ 'T' und 'T' angewendet werden. Ich frage mich warum, denn soweit ich das verstehe ist der == Operator für alle Typen vordefiniert?

Bearbeiten: Vielen Dank an alle. Ich habe zunächst nicht bemerkt, dass es in der Aussage nur um Referenztypen ging. Ich dachte auch, dass Bit-für-Bit-Vergleich für alle Werttypen zur Verfügung gestellt wird, die ich jetzt weiß, ist nicht richtig.

Aber wenn ich einen Referenztyp verwende, würde der Operator == den vordefinierten Referenzvergleich verwenden, oder würde er die überladene Version des Operators verwenden, wenn ein Typ definiert ist?

Bearbeiten 2: Durch Versuch und Irrtum erfuhren wir, dass der Operator == den vordefinierten Referenzvergleich verwenden wird, wenn ein unbeschränkter generischer Typ verwendet wird. Tatsächlich wird der Compiler die beste Methode verwenden, die er für das Argument mit eingeschränktem Typ finden kann, wird aber nicht weiter suchen. Zum Beispiel wird der folgende Code immer true drucken, auch wenn Test.test<B>(new B(), new B()) genannt wird:

class A { public static bool operator==(A x, A y) { return true; } } 
class B : A { public static bool operator==(B x, B y) { return false; } } 
class Test { void test<T>(T a, T b) where T : A { Console.WriteLine(a == b); } } 

Answer 1

"... standardmäßig == verhält sich wie oben für vordefinierte und benutzerdefinierte Referenztypen beschrieben."

Typ T ist nicht unbedingt ein Referenztyp, daher kann der Compiler diese Annahme nicht treffen.

Dies wird jedoch kompilieren, weil es explizit:

bool Compare<T>(T x, T y) where T : class 
    { 
     return x == y; 
    } 

Folgen auf weitere Frage auf: „Aber falls ich einen Referenztyp verwendet wird, würde der der Operator == die Verwendung vordefinierte Referenzvergleich, oder würde es die überladene Version des Operators verwenden, wenn ein Typ definiert? "

Ich hätte gedacht, dass == auf dem Generics die überladene Version verwenden würde, aber der folgende Test zeigt etwas anderes. Interessant ... Ich würde gerne wissen, warum! Wenn jemand weiß, bitte teilen.

namespace TestProject 
{ 
class Program 
{ 
    static void Main(string[] args) 
    { 
     Test a = new Test(); 
     Test b = new Test(); 

     Console.WriteLine("Inline:"); 
     bool x = a == b; 
     Console.WriteLine("Generic:"); 
     Compare<Test>(a, b); 

    } 


    static bool Compare<T>(T x, T y) where T : class 
    { 
     return x == y; 
    } 
} 

class Test 
{ 
    public static bool operator ==(Test a, Test b) 
    { 
     Console.WriteLine("Overloaded == called"); 
     return a.Equals(b); 
    } 

    public static bool operator !=(Test a, Test b) 
    { 
     Console.WriteLine("Overloaded != called"); 
     return a.Equals(b); 
    } 
    } 
} 

Ausgabe

Inline:

Drücken Sie eine beliebige Taste, um fortzufahren: == überladene

Generika genannt. . .

Follow Up 2

möchte ich darauf hinweisen, dass meine vergleichen Methode

static bool Compare<T>(T x, T y) where T : Test 
    { 
     return x == y; 
    } 

Veränderung bewirkt, dass der überladenen Operator == aufgerufen werden. Ich denke, ohne Angabe des Typs (als wo) kann der Compiler nicht schließen, dass es den überladenen Operator verwenden soll ... obwohl ich denke, dass es genug Informationen hätte, um diese Entscheidung auch ohne Angabe des Typs zu treffen .

Answer 2

Die Kompilierung kann nicht wissen, T nicht eine Struktur (Werttyp) sein könnte. Also muss man es sagen, kann es nur von Referenztyp sein ich denke:

bool Compare<T>(T x, T y) where T : class { return x == y; } 

Es weil ist, wenn T ein Werttyp sein könnte, es Fälle geben könnte, wo x == y wäre schlecht gebildet werden - in den Fällen, wenn ein Typ doesn habe keinen Operator == definiert. Das gleiche gilt für diese die geschehen wird, ist offensichtlich:

void CallFoo<T>(T x) { x.foo(); } 

Das ist zu fehlschlägt, weil Sie einen Typ T passieren könnten, die keine Funktion foo haben würde. C# zwingt Sie, sicherzustellen, dass alle möglichen Typen immer eine Funktion foo haben. Das macht die where-Klausel.

Answer 3

 

bool Compare(T x, T y) where T : class { return x == y; } 
 

Das obige funktioniert, weil == bei benutzerdefinierten Referenztypen berücksichtigt wird.
Bei Werttypen kann == außer Kraft gesetzt werden. In diesem Fall sollte auch "! =" Definiert werden.

Ich denke, das könnte der Grund sein, es verbietet generischen Vergleich mit "==".

Answer 4

Es scheint, dass ohne die Klasse Einschränkung:

bool Compare<T> (T x, T y) where T: class 
{ 
    return x == y; 
} 

Man sollte erkennen, dass, während classEquals eingeschränkt in den == Betreibern von Object.Equals erbt, während die von einer Struktur ValueType.Equals außer Kraft setzt.

Beachten Sie, dass:

bool Compare<T> (T x, T y) where T: struct 
{ 
    return x == y; 
} 

gibt auch den gleichen Compiler-Fehler aus.

Bis jetzt verstehe ich nicht, warum ein Gleichheitsoperatorvergleich vom Werttyp vom Compiler abgelehnt wird.Ich weiß allerdings, für eine Tatsache, dass dies funktioniert:

bool Compare<T> (T x, T y) 
{ 
    return x.Equals(y); 
} 

Answer 5

Wie andere gesagt haben, es wird nur funktionieren, wenn T gezwungen ist, ein Referenztyp zu sein. Ohne Einschränkungen können Sie mit null vergleichen, aber nur mit null - und dieser Vergleich ist immer falsch für Nicht-Nullable-Werttypen.

Statt Equals zu nennen, dann ist es besser, ein IComparer<T> zu verwenden - und wenn Sie keine weiteren Informationen haben, ist EqualityComparer<T>.Default eine gute Wahl:

public bool Compare<T>(T x, T y) 
{ 
    return EqualityComparer<T>.Default.Equals(x, y); 
} 

von etwas Neben anderen, dies vermeidet Box/Gießen.

Answer 6

Im Allgemeinen sollte EqualityComparer<T>.Default.Equals die Arbeit mit allem, das IEquatable<T> implementiert, oder das eine sinnvolle Implementierung Equals hat.

Wenn jedoch == und Equals aus irgendeinem Grund anders implementiert werden, dann sollte meine Arbeit an generic operators nützlich sein; Es unterstützt die Betreiber Versionen von (unter anderem):

• Equal (T value1, T Wert2)
• Ungleich (T value1, T Wert2)
• GreaterThan (T value1, T Wert2)
• LessThan (T Wert1, Wert2 T)
• GreaterThanOrEqual (T Wert1, T Wert2)
• LessThanOrEqual (T Wert1, T Wert2)

Answer 7

Es ist ein MSDN Connect-Eintrag für diesen here

Alex Antwort Turner beginnt mit:

Leider ist dieses Verhalten von Design und es gibt keine einfache Lösung Verwendung von == zu ermöglichen mit Typ Parameter, die Wert Typen enthalten können.

Answer 8

So viele Antworten, und nicht eine einzige erklärt das WARUM? (was Giovanni explizit gefragt hat) ...

.NET-Generics funktionieren nicht wie C++ - Vorlagen. In C++ - Vorlagen tritt die Überladungsauflösung auf, nachdem die tatsächlichen Vorlagenparameter bekannt sind.

In .NET-Generics (einschließlich C#) tritt die Überladungsauflösung auf, ohne die tatsächlichen generischen Parameter zu kennen. Die einzige Information, die der Compiler verwenden kann, um die aufzurufende Funktion auszuwählen, kommt von Typbeschränkungen für die generischen Parameter.

Answer 9

Wenn Sie sicherstellen möchten, dass die Operatoren Ihres benutzerdefinierten Typs aufgerufen werden, können Sie dies über die Reflektion tun. Holen Sie sich einfach den Typ mit Ihrem generischen Parameter und rufen Sie die MethodInfo für den gewünschten Operator ab (z. B. op_Equality, op_Inequality, op_LessThan ...).

var methodInfo = typeof (T).GetMethod("op_Equality", 
          BindingFlags.Static | BindingFlags.Public);  

auszuführen Dann der Bediener die Method des Invoke-Methode und in die Objekte als Parameter übergeben.

var result = (bool) methodInfo.Invoke(null, new object[] { object1, object2}); 

Dies ruft Ihren überladenen Operator auf und nicht den, der durch die Einschränkungen definiert ist, die für den generischen Parameter gelten. Dies ist möglicherweise nicht praktisch, könnte sich aber als nützlich erweisen, wenn Sie Ihre Operatoren testen möchten, wenn Sie eine generische Basisklasse verwenden, die einige Tests enthält.

Answer 10

Ich schrieb die folgende Funktion mit Blick auf die neueste msdn. Es kann leicht zwei Objekte x und y vergleichen:

static bool IsLessThan(T x, T y) 
{ 
    return ((IComparable)(x)).CompareTo(y) <= 0; 
} 

Answer 11

Nun, in meinem Fall ich Unit-Test wollte den Gleichheitsoperator. Ich brauchte den Code unter den Gleichheitsoperatoren aufrufen, ohne explizit den generischen Typ zu setzen. Hinweise für EqualityComparer waren nicht hilfreich wie EqualityComparer genannt Equals Methode, aber nicht der Gleichheitsoperator.

Hier ist, wie ich dies mit generischen Typen arbeiten durch den Aufbau einer LINQ. Er fordert den richtigen Code für == und != Operatoren:

/// <summary> 
/// Gets the result of "a == b" 
/// </summary> 
public bool GetEqualityOperatorResult<T>(T a, T b) 
{ 
    // declare the parameters 
    var paramA = Expression.Parameter(typeof(T), nameof(a)); 
    var paramB = Expression.Parameter(typeof(T), nameof(b)); 
    // get equality expression for the parameters 
    var body = Expression.Equal(paramA, paramB); 
    // compile it 
    var invokeEqualityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile(); 
    // call it 
    return invokeEqualityOperator(a, b); 
} 

/// <summary> 
/// Gets the result of "a =! b" 
/// </summary> 
public bool GetInequalityOperatorResult<T>(T a, T b) 
{ 
    // declare the parameters 
    var paramA = Expression.Parameter(typeof(T), nameof(a)); 
    var paramB = Expression.Parameter(typeof(T), nameof(b)); 
    // get equality expression for the parameters 
    var body = Expression.NotEqual(paramA, paramB); 
    // compile it 
    var invokeInequalityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile(); 
    // call it 
    return invokeInequalityOperator(a, b); 
}