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

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

Für vordefinierte Werttypen gibt der Gleichheitsoperator (==) true zurück, wenn die Werte seiner Operanden gleich sind, andernfalls false. Für andere Referenztypen als Zeichenfolge gibt == true zurück, wenn sich die beiden Operanden auf dasselbe Objekt beziehen. Für den Zeichenfolgentyp vergleicht == die Werte der Zeichenfolgen. Benutzerdefinierte Werttypen können den Operator == überladen (siehe Operator). Dies gilt auch für benutzerdefinierte Referenztypen, obwohl sich == standardmäßig wie oben für vordefinierte und benutzerdefinierte Referenztypen beschrieben verhält.

Warum kann dieses Code-Snippet nicht kompiliert werden?

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

Ich erhalte den Fehler Operator '==' kann nicht auf Operanden vom Typ 'T' und 'T' angewendet werden . Ich frage mich warum, da der ==Operator meines Wissens für alle Typen vordefiniert ist.

Edit: Danke an alle. Ich habe zunächst nicht bemerkt, dass es sich bei der Aussage nur um Referenztypen handelt. Ich dachte auch, dass ein bitweiser Vergleich für alle Werttypen bereitgestellt wird, von denen ich jetzt weiß, dass sie nicht korrekt sind.

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

Bearbeiten 2: Durch Versuch und Irrtum haben wir erfahren, dass der ==Operator den vordefinierten Referenzvergleich verwendet, wenn er einen uneingeschränkten generischen Typ verwendet. Tatsächlich verwendet der Compiler die beste Methode, die er für das Argument des eingeschränkten Typs finden kann, sucht jedoch nicht weiter. Der folgende Code wird beispielsweise immer gedruckt true, auch wenn er Test.test<B>(new B(), new B())aufgerufen 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); } }

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

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

Dies wird jedoch kompiliert, da es expliziter ist:

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

Folgen Sie der zusätzlichen Frage: "Wenn ich jedoch einen Referenztyp verwende, würde der Operator == den vordefinierten Referenzvergleich verwenden oder würde er die überladene Version des Operators verwenden, wenn ein Typ einen definiert?"

Ich hätte gedacht, dass == auf den Generika 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: Überladen == aufgerufen

Generisch:

Drücken Sie eine beliebige Taste, um fortzufahren . . .

Follow Up 2

Ich möchte darauf hinweisen, dass ich meine Vergleichsmethode auf ändere

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

bewirkt, dass der überladene Operator == aufgerufen wird. Ich denke, ohne Angabe des Typs (als Wo ) kann der Compiler nicht schließen, dass er den überladenen Operator verwenden sollte ... obwohl ich denke, dass er genügend Informationen hätte, um diese Entscheidung zu treffen, auch ohne Angabe des Typs.

Wie andere gesagt haben, funktioniert es nur, wenn T auf einen Referenztyp beschränkt ist. Ohne Einschränkungen können Sie mit null vergleichen, aber nur mit null - und dieser Vergleich ist für nicht nullfähige Werttypen immer falsch.

Anstatt Equals aufzurufen, ist es besser, ein zu verwenden IComparer<T>- und wenn Sie keine weiteren Informationen haben, EqualityComparer<T>.Defaultist dies eine gute Wahl:

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

Abgesehen von allem anderen vermeidet dies Boxen / Casting.

Im Allgemeinen EqualityComparer<T>.Default.Equalssollte die Arbeit mit allem erledigt werden IEquatable<T>, was implementiert wird oder was eine vernünftige EqualsImplementierung hat.

Wenn jedoch ==und Equalsanders aus irgendwelchen Gründen umgesetzt werden, dann meine Arbeit an generischen Operationen sollte nützlich sein; Es unterstützt unter anderem die Operator- Versionen von:

• Gleich (T-Wert1, T-Wert2)
• NotEqual (T-Wert1, T-Wert2)
• Größer als (T-Wert1, T-Wert2)
• LessThan (T-Wert1, T-Wert2)
• GreaterThanOrEqual (T-Wert1, T-Wert2)
• LessThanOrEqual (T-Wert1, T-Wert2)

So viele Antworten und keine einzige erklärt das WARUM? (was Giovanni ausdrücklich fragte) ...

.NET-Generika verhalten sich nicht wie C ++ - Vorlagen. In C ++ - Vorlagen tritt eine Überlastungsauflösung auf, nachdem die tatsächlichen Vorlagenparameter bekannt sind.

In .NET-Generika (einschließlich C #) tritt eine Überlastungsauflösung auf, ohne die tatsächlichen generischen Parameter zu kennen. Die einzigen Informationen, die der Compiler zur Auswahl der aufzurufenden Funktion verwenden kann, stammen aus Typbeschränkungen für die generischen Parameter.

Die Kompilierung kann nicht wissen, dass T keine Struktur (Werttyp) sein kann. Sie müssen also sagen, dass es nur vom Referenztyp sein kann, denke ich:

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

Dies liegt daran, dass wenn T ein Werttyp sein könnte, es Fälle geben könnte, in denen x == yeine Fehlbildung vorliegt - in Fällen, in denen für einen Typ kein Operator == definiert ist. Dasselbe wird dafür passieren, was offensichtlicher ist:

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

Das schlägt auch fehl, weil Sie einen Typ T übergeben könnten, der keine Funktion foo hätte. C # zwingt Sie sicherzustellen, dass alle möglichen Typen immer eine Funktion foo haben. Dies geschieht durch die where-Klausel.

Es scheint, dass ohne die Klassenbeschränkung:

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

Man sollte sich darüber im Klaren sein, dass während eine classEinschränkung Equalsim ==Operator von erbt Object.Equals, während die einer Struktur überschreibt ValueType.Equals.

Beachten Sie, dass:

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

gibt auch den gleichen Compilerfehler aus.

Bis jetzt verstehe ich nicht, warum ein Vergleich des Werttyp-Gleichheitsoperators vom Compiler abgelehnt wird. Ich weiß jedoch, dass dies funktioniert:

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

Nun, in meinem Fall wollte ich den Gleichheitsoperator einem Unit-Test unterziehen. Ich musste den Code unter den Gleichheitsoperatoren aufrufen, ohne den generischen Typ explizit festzulegen. Ratschläge für EqualityComparerwaren als EqualityCompareraufgerufene EqualsMethode nicht hilfreich , aber nicht als Gleichheitsoperator.

Hier ist, wie ich das mit generischen Typen arbeiten lasse, indem ich ein baue LINQ. Es ruft den richtigen Code für ==und !=Operatoren auf:

/// <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);
}

Es gibt eine MSDN Connect - Eintrag für diese hier

Die Antwort von Alex Turner beginnt mit:

Leider ist dieses Verhalten beabsichtigt und es gibt keine einfache Lösung, um die Verwendung von == mit Typparametern zu ermöglichen, die Werttypen enthalten können.

Wenn Sie sicherstellen möchten, dass die Operatoren Ihres benutzerdefinierten Typs aufgerufen werden, können Sie dies über Reflection tun. Rufen Sie einfach den Typ mit Ihrem generischen Parameter ab 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);    

Führen Sie dann den Operator mit der Invoke-Methode von MethodInfo aus und übergeben Sie die Objekte als Parameter.

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

Dadurch wird Ihr überladener Operator aufgerufen und nicht derjenige, der durch die auf den generischen Parameter angewendeten Einschränkungen definiert ist. Dies ist möglicherweise nicht praktikabel, kann sich jedoch als nützlich für Unit-Tests Ihrer Bediener erweisen, wenn Sie eine generische Basisklasse verwenden, die einige Tests enthält.

Ich habe die folgende Funktion geschrieben und mir die neueste msdn angesehen. Es kann leicht zwei Objekte vergleichen xund y:

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

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

Dies funktioniert, da == bei benutzerdefinierten Referenztypen berücksichtigt wird.
Bei Werttypen kann == überschrieben werden. In diesem Fall sollte auch "! =" Definiert werden.

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

Das .Equals()funktioniert bei mir zwar TKeyein generischer Typ.

public virtual TOutputDto GetOne(TKey id)
{
    var entity =
        _unitOfWork.BaseRepository
            .FindByCondition(x => 
                !x.IsDelete && 
                x.Id.Equals(id))
            .SingleOrDefault();


    // ...
}