Opérateur '??' ne peut pas être appliqué aux opérandes de type 'T' et 'T'

Question

J'ai la méthode générique suivante, mais VS me donne une erreur de compilation à ce sujet. (L'opérateur '??' ne peut pas être appliqué aux opérandes de type 'T' et 'T')

 public static T Method<T>(T model) where T : new()
{
    var m = model ?? new T();
}
 

Quelqu'un a-t-il une idée de pourquoi?

Edit: Est-il possible que la raison en soit que T peut être une structure dans mon cas, et qu'une structure est un type non nullable?

Answer 1

?? est l'opérateur de coalescence nulle. Il ne peut pas être appliqué à des types non nullables. Puisque T peut être n'importe quoi, il peut s'agir d'un int ou d'un autre type primitif, non nullable.

Si vous ajoutez la condition where T : class (doit être spécifiée avant new() ), il oblige T à être une instance de classe qui peut être définie à l'état null.

Answer 2

Vous devez ajouter class contrainte:

public static T Method<T>(T model) where T : class, new()
{
    var m = model ?? new T();

    return m;
}

Et vous devez retourner m trop!

Remarque: Comme @KristofDegrave mentionné dans son commentaire, la raison pour laquelle nous devons ajouter class contrainte est parce que T peut être un type de valeur, comme int et depuis ?? opérateur (null-coalescence) vérification des types qui peuvent être nulles, alors nous devons ajouter class de la contrainte à exclure des types de valeur.

Edit: Alvin Wong répondre à couvert le cas pour les types nullables trop; qui sont des structures en fait, mais peut être opérandes ?? de l'opérateur. Juste être conscient que Method reviendrait null sans Alvin de la version surchargée, pour les types nullables.

Answer 3

Beaucoup ont déjà fait remarquer que l'ajout de la contrainte class pour le générique résoudrait le problème.

Si vous souhaitez que votre méthode soit également applicable à Nullable<T> , vous pouvez lui ajouter une surcharge:

 // For reference types
public static T Method<T>(T model) where T : class, new()
{
    return model ?? new T();
}

// For Nullable<T>
public static T Method<T>(T? model) where T : struct
{
    return model ?? new T(); // OR
    return model ?? default(T);
}
 

Answer 4

Vous devez spécifier que votre type T est une classe avec une contrainte sur le type générique:

 public static T Method<T>(T model) where T : class, new()
{
    return model ?? new T();
}
 

Answer 5

Puisque T peut être n’importe quel type, il n’ya aucune garantie que T aura un statique ?? opérateur ou que le type T est nullable.

?? Opérateur (référence C #)

Le ?? L'opérateur s'appelle l'opérateur null-coalescing et permet de définir une valeur par défaut pour les types de valeur nullable ou les types de référence .