Comparaison d'un argument générique par défaut ou nul en C#

Question

J'ai une méthode générique définie comme ceci :

public void MyMethod<T>(T myArgument)

La première chose que je veux faire est de vérifier si la valeur de myArgument est la valeur par défaut pour ce type, quelque chose comme ceci :

if (myArgument == default(T))

Mais cela ne compile pas car je n'ai pas garanti que T implémentera l'opérateur ==. J'ai donc changé le code en ceci :

if (myArgument.Equals(default(T)))

Maintenant, cela compile, mais échouera si myArgument est nul, ce qui fait partie de ce que je teste. Je peux ajouter une vérification explicite de null comme ceci :

if (myArgument == null || myArgument.Equals(default(T)))

Maintenant, ça me semble redondant. ReSharper me suggère même de changer la partie myArgument == null en myArgument == default(T), ce qui est le point de départ. Existe-t-il une meilleure façon de résoudre ce problème ?

Je dois soutenir les deux les types de références et les types de valeurs.

Answer 1

Pour éviter la mise en boîte, la meilleure façon de comparer les génériques pour l'égalité est avec EqualityComparer<T>.Default . Cela respecte IEquatable<T> (sans boxe) ainsi que object.Equals et s'occupe de tous les Nullable<T> des nuances "soulevées". D'où :

if(EqualityComparer<T>.Default.Equals(obj, default(T))) {
    return obj;
}

Cela correspondra :

• nul pour les classes
• null (vide) pour Nullable<T>
• zero/false/etc pour les autres structs

Answer 2

Que dites-vous de ça ?

if (object.Equals(myArgument, default(T)))
{
    //...
}

Utilisation de la static object.Equals() vous évite d'avoir à effectuer les opérations suivantes null vérifiez vous-même. En qualifiant explicitement l'appel avec object. n'est probablement pas nécessaire en fonction de votre contexte, mais je préfère normalement préfixer static avec le nom du type juste pour rendre le code plus soluble.

Answer 3

J'ai pu trouver un Article sur Microsoft Connect qui traite de cette question en détail :

Malheureusement, ce comportement est dû à la conception et il n'existe pas de solution simple pour permettre l'utilisation de paramètres de type avec qui peuvent contenir des types de valeurs.

Si les types sont connus pour être des types de référence, la surcharge par défaut de defined on object teste les variables pour l'égalité de référence, bien qu'un type puisse spécifier sa propre surcharge personnalisée. Le compilateur détermine la surcharge à utiliser en fonction du type statique de la variable (la détermination n'est pas polymorphe). Par conséquent, si vous modifiez votre exemple pour contraindre le paramètre de type générique T à un type de référence non scellé (tel que Exception), le compilateur peut déterminer la surcharge spécifique à utiliser et le code suivant sera compilé :

public class Test<T> where T : Exception

Si les types sont connus pour être des types de valeur, effectue des tests d'égalité de valeur spécifiques basés sur les types exacts utilisés. Il n'y a pas de bonne comparaison "par défaut" ici puisque les comparaisons de référence n'ont pas de sens sur les types de valeur et que le compilateur ne peut pas savoir quelle comparaison de valeur spécifique émettre. Le compilateur pourrait émettre un appel à ValueType.Equals(Object) mais cette méthode utilise la réflexion et est assez inefficace par rapport aux comparaisons de valeurs spécifiques. Par conséquent, même si vous deviez spécifier une contrainte de type de valeur sur T, le compilateur n'a rien de raisonnable à générer ici :

public class Test<T> where T : struct

Dans le cas que vous avez présenté, où le compilateur ne sait même pas si T est un type valeur ou référence, il n'y a de même rien à générer qui serait valide pour tous les types possibles. Une comparaison de référence ne serait pas valide pour les types valeur et une sorte de comparaison de valeur serait inattendue pour les types référence qui ne surchargent pas.

Voici ce que vous pouvez faire...

J'ai validé que ces deux méthodes fonctionnent pour une comparaison générique des types de référence et de valeur :

object.Equals(param, default(T))

ou

EqualityComparer<T>.Default.Equals(param, default(T))

Pour effectuer des comparaisons avec l'opérateur "==", vous devez utiliser l'une de ces méthodes :

Si tous les cas de T dérivent d'une classe de base connue, vous pouvez le faire savoir au compilateur en utilisant des restrictions de type génériques.

public void MyMethod<T>(T myArgument) where T : MyBase

Le compilateur reconnaît alors comment effectuer des opérations sur MyBase et ne produira pas l'erreur "Operator '==' cannot be applied to operands of type 'T' and 'T'" que vous voyez actuellement.

Une autre option serait de restreindre T à tout type qui implémente IComparable .

public void MyMethod<T>(T myArgument) where T : IComparable

Et ensuite utiliser le CompareTo définie par la méthode Interface IComparable .

Answer 4

Essayez ça :

if (EqualityComparer<T>.Default.Equals(myArgument, default(T)))

qui devrait compiler, et faire ce que vous voulez.

Answer 5

Pour gérer tous les types de T, y compris lorsque T est un type primitif, vous devrez compiler les deux méthodes de comparaison :

    T Get<T>(Func<T> createObject)
    {
        T obj = createObject();
        if (obj == null || obj.Equals(default(T)))
            return obj;

        // .. do a bunch of stuff
        return obj;
    }