Null ou de comparaison par défaut de l'argument générique en C#

Pour éviter la boxe, la meilleure façon de comparer les génériques pour l'égalité est avec EqualityComparer<T>.Default. Ce respecte IEquatable<T> (sans la boxe) ainsi que object.Equals, et s'occupe de toutes les Nullable<T> "levé" nuances. Donc:

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

Ce sera un match:

• null pour les classes
• null (vide) pour Nullable<T>
• zéro/faux/etc pour les autres structures

J'ai été capable de localiser un Microsoft se Connecter à l'article qui traite de cette question dans le détail:

Malheureusement, ce comportement est voulu par la conception et il n'y a pas une solution facile à utiliser avec les paramètres de type qui peut contenir des types de valeur.

Si les types sont connus pour être les types de référence, la valeur par défaut de surcharge de défini sur l'objet de tests de variables de référence de l'égalité, bien qu'un type peut spécifier ses propres surcharge. 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 changez d'exemple pour contraindre le paramètre de type générique T à un non-scellé type de référence (telles que l'Exception), le compilateur peut déterminer la surcharge d'utilisation et le code suivant devrait compiler:

public class Test<T> where T : Exception

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

public class Test<T> where T : struct

Dans le cas où 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 même rien à générer qui serait valable pour tous les types possibles. Une référence de comparaison ne serait pas valable pour les types valeur et de la valeur de comparaison, ce serait inattendu pour les types de référence qui ne sont pas de surcharge.

Ici est ce que vous pouvez faire...

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

object.Equals(param, default(T))

ou

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

De faire des comparaisons avec le "==" l'opérateur, vous aurez besoin d'utiliser une de ces méthodes:

Si tous les cas de T dériver à partir d'une classe de base, vous pouvez laisser le compilateur d'aide de type générique restrictions.

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

Le compilateur reconnaît alors comment faire pour effectuer des opérations sur les MyBase et de ne pas jeter le "Opérateur '==' ne peut pas être appliquée à des opérandes de type 'T' et 'T'" erreur que vous voyez maintenant.

Une autre option serait de restreindre T de n'importe quel type qui implémente IComparable.

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

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

(Édité)

Marc Gravel a la meilleure réponse, mais je voulais poster un simple fragment de code suivant, j'ai travaillé jusqu'à le démontrer. Lancez-le dans une simple console C# app:

public static class TypeHelper<T>
{
    public static bool IsDefault(T val)
    {
         return EqualityComparer<T>.Default.Equals(obj,default(T));
    }
}

static void Main(string[] args)
{
    //value type
    Console.WriteLine(TypeHelper<int>.IsDefault(1)); //False
    Console.WriteLine(TypeHelper<int>.IsDefault(0)); //True

    //reference type
    Console.WriteLine(TypeHelper<string>.IsDefault("test")); //False
    Console.WriteLine(TypeHelper<string>.IsDefault(null)); //True //True

    Console.ReadKey();
}

Une chose: quelqu'un peut-il avec VS2008 essayer cela comme une extension de la méthode? Je suis coincé ici à 2005 et je suis curieux de voir si cela serait autorisé.

---

Edit: Ici est de savoir comment le faire fonctionner comme une extension de la méthode:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        //value type
        Console.WriteLine(1.IsDefault());
        Console.WriteLine(0.IsDefault());

        //reference type
        Console.WriteLine("test".IsDefault());
        //null must be cast to a type
        Console.WriteLine(((String)null).IsDefault());
    }
}

//The type cannot be generic
public static class TypeHelper
{
    //I made the method generic instead
    public static bool IsDefault<T>(this T val)
    {
        return EqualityComparer<T>.Default.Equals(val, default(T));
    }
}

Il va y avoir un problème ici -

Si vous allez permettre que cela fonctionne pour n'importe quel type, par défaut(T) sera toujours null pour les types référence, et 0 (ou structure complète de 0) pour les types de valeur.

Ce n'est probablement pas le comportement que vous êtes après, si. Si vous voulez que cela fonctionne de manière générique, vous avez probablement besoin d'utiliser la réflexion pour vérifier le type de T, et la poignée de la valeur des types différents de types de référence.

Alternativement, vous pouvez mettre une contrainte d'interface sur ce point, et l'interface pourrait offrir un moyen de vérifier que le défaut de la class/struct.

J'utilise:

public class MyClass<T>
{
  private bool IsNull() 
  {
    var nullable = Nullable.GetUnderlyingType(typeof(T)) != null;
    return nullable ? EqualityComparer<T>.Default.Equals(Value, default(T)) : false;
  }
}

@ilitirit:

public class Class<T> where T : IComparable
{
    public T Value { get; set; }
    public void MyMethod(T val)
    {
        if (Value == val)
            return;
    }
}

Opérateur '==' ne peut pas être appliquée à des opérandes de type 'T' et 'T'

Je ne peux pas penser à un moyen de le faire sans l'explicite null test suivi par l'invocation de la méthode Equals ou d'un objet.Égal comme suggéré ci-dessus.

Vous pouvez concevoir une solution en utilisant le Système.La comparaison, mais vraiment c'est la fin avec beaucoup plus de lignes de code et d'augmenter considérablement la complexité.