L'opérateur == ne peut-il pas être appliqué aux types génériques en C #?

Selon la documentation de l' ==opérateur dans MSDN ,

Pour les types de valeurs prédéfinis, l'opérateur d'égalité (==) renvoie true si les valeurs de ses opérandes sont égales, false sinon. Pour les types de référence autres que chaîne, == renvoie true si ses deux opérandes font référence au même objet. Pour le type de chaîne, == compare les valeurs des chaînes. Les types de valeurs définis par l'utilisateur peuvent surcharger l'opérateur == (voir opérateur). Il en va de même pour les types de référence définis par l'utilisateur, bien que par défaut == se comporte comme décrit ci-dessus pour les types de référence prédéfinis et définis par l'utilisateur.

Alors pourquoi cet extrait de code ne parvient-il pas à être compilé?

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

J'obtiens l'erreur Operator '==' ne peut pas être appliqué aux opérandes de type 'T' et 'T' . Je me demande pourquoi, dans la mesure où je comprends l' ==opérateur est prédéfini pour tous les types?

Edit: Merci à tous. Je n'ai pas remarqué au début que la déclaration concernait uniquement les types de référence. J'ai également pensé que la comparaison bit par bit est fournie pour tous les types de valeur, ce que je sais maintenant n'est pas correct.

Mais, dans le cas où j'utilise un type de référence, l' ==opérateur utiliserait-il la comparaison de référence prédéfinie, ou utiliserait-il la version surchargée de l'opérateur si un type en définissait un?

Edit 2: Par essais et erreurs, nous avons appris que l' ==opérateur utilisera la comparaison de référence prédéfinie lors de l'utilisation d'un type générique sans restriction. En fait, le compilateur utilisera la meilleure méthode qu'il puisse trouver pour l'argument de type restreint, mais ne cherchera pas plus loin. Par exemple, le code ci-dessous sera toujours imprimé true, même lorsqu'il Test.test<B>(new B(), new B())est appelé:

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

"... par défaut == se comporte comme décrit ci-dessus pour les types de référence prédéfinis et définis par l'utilisateur."

Le type T n'est pas nécessairement un type de référence, le compilateur ne peut donc pas faire cette hypothèse.

Cependant, cela se compilera car il est plus explicite:

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

Suivi d'une question supplémentaire: "Mais, si j'utilise un type de référence, l'opérateur == utiliserait-il la comparaison de référence prédéfinie, ou utiliserait-il la version surchargée de l'opérateur si un type en définissait un?"

J'aurais pensé que == sur les génériques utiliserait la version surchargée, mais le test suivant démontre le contraire. Intéressant ... j'aimerais savoir pourquoi! Si quelqu'un sait, veuillez partager.

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

Production

Inline: surchargé == appelé

Générique:

Appuyez sur n'importe quelle touche pour continuer . . .

Suivi 2

Je tiens à souligner que changer ma méthode de comparaison en

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

provoque l'appel de l'opérateur == surchargé. Je suppose que sans spécifier le type (comme où ), le compilateur ne peut pas déduire qu'il devrait utiliser l'opérateur surchargé ... bien que je pense qu'il aurait suffisamment d'informations pour prendre cette décision même sans spécifier le type.

Comme d'autres l'ont dit, cela ne fonctionnera que lorsque T est contraint d'être un type de référence. Sans aucune contrainte, vous pouvez comparer avec null, mais seulement null - et cette comparaison sera toujours false pour les types de valeur non nullable.

Au lieu d'appeler Equals, il est préférable d'utiliser un IComparer<T>- et si vous n'avez plus d'informations, EqualityComparer<T>.Defaultc'est un bon choix:

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

Mis à part toute autre chose, cela évite la boxe / casting.

En général, EqualityComparer<T>.Default.Equalsdevrait faire le travail avec tout ce qui met en œuvre IEquatable<T>, ou qui a un sensEquals implémentation .

Si, cependant, ==et Equalssont mis en œuvre différemment pour une raison quelconque, alors mon travail sur les opérateurs génériques devrait être utile; il prend en charge les versions opérateur de (entre autres):

• Égal (valeur T1, valeur T2)
• NotEqual (valeur T1, valeur T2)
• GreaterThan (valeur T1, valeur T2)
• LessThan (valeur T1, valeur T2)
• GreaterThanOrEqual (valeur T1, valeur T2)
• LessThanOrEqual (valeur T1, valeur T2)

Autant de réponses, et pas une seule n'explique le POURQUOI? (que Giovanni a explicitement demandé) ...

Les génériques .NET n'agissent pas comme des modèles C ++. Dans les modèles C ++, la résolution de surcharge se produit une fois que les paramètres réels du modèle sont connus.

Dans les génériques .NET (y compris C #), la résolution de surcharge se produit sans connaître les paramètres génériques réels. Les seules informations que le compilateur peut utiliser pour choisir la fonction à appeler proviennent des contraintes de type sur les paramètres génériques.

La compilation ne peut pas savoir que T ne peut pas être un struct (type de valeur). Il faut donc lui dire que ça ne peut être que de type référence je pense:

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

C'est parce que si T pourrait être un type de valeur, il pourrait y avoir des cas où il x == yserait mal formé - dans les cas où un type n'a pas d'opérateur == défini. La même chose se produira pour ce qui est plus évident:

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

Cela échoue également, car vous pourriez passer un type T qui n'aurait pas de fonction foo. C # vous oblige à vous assurer que tous les types possibles ont toujours une fonction foo. Cela se fait par la clause where.

Il semble que sans la contrainte de classe:

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

Il faut se rendre compte que tandis que classcontraint Equalsdans l' ==opérateur hérite de Object.Equals, tandis que celui d'une structure remplaceValueType.Equals .

Notez que:

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

donne également la même erreur de compilation.

Pour l'instant, je ne comprends pas pourquoi le compilateur rejette une comparaison d'opérateurs d'égalité de type valeur. Je sais cependant que cela fonctionne:

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

Eh bien dans mon cas, je voulais tester unitairement l'opérateur d'égalité. J'avais besoin d'appeler le code sous les opérateurs d'égalité sans définir explicitement le type générique. Conseils pour le EqualityComparersont pas utiles comme EqualityComparerappeléEquals méthode mais pas pour l'opérateur d'égalité.

Voici comment j'ai pu travailler avec des types génériques en créant un fichier LINQ. Il appelle le bon code pour ==et les !=opérateurs:

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

Il existe une entrée MSDN Connect pour ce ici

La réponse d'Alex Turner commence par:

Malheureusement, ce comportement est inhérent à la conception et il n'y a pas de solution simple pour activer l'utilisation de == avec des paramètres de type qui peuvent contenir des types de valeur.

Si vous voulez vous assurer que les opérateurs de votre type personnalisé sont appelés, vous pouvez le faire via la réflexion. Obtenez simplement le type en utilisant votre paramètre générique et récupérez le MethodInfo pour l'opérateur souhaité (par exemple op_Equality, op_Inequality, op_LessThan ...).

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

Exécutez ensuite l'opérateur à l'aide de la méthode Invoke de MethodInfo et passez les objets en tant que paramètres.

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

Cela invoquera votre opérateur surchargé et non celui défini par les contraintes appliquées au paramètre générique. Cela pourrait ne pas être pratique, mais pourrait s'avérer utile pour tester vos opérateurs en unité lors de l'utilisation d'une classe de base générique qui contient quelques tests.

J'ai écrit la fonction suivante en regardant la dernière msdn. Il peut facilement comparer deux objets xet 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; }

Ce qui précède fonctionnera car == est pris en charge dans le cas de types de référence définis par l'utilisateur.
Dans le cas des types de valeur, == peut être remplacé. Dans ce cas, "! =" Doit également être défini.

Je pense que cela pourrait être la raison, cela interdit la comparaison générique en utilisant "==".

Le .Equals()travail pour moi TKeyest un type générique.

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


    // ...
}