Comment puis-je savoir si le type d'un objet est Nullable <T> en utilisant la réflexion?

Question

Si j'ai un Type, est-il un moyen facile de dire qu'il représente un type de valeur Nullable en utilisant Reflection? Idéalement quelque chose d'un peu plus propre (et plus correct) que:.

static bool IsNullable(Type type) 
{ 
    return type.IsValueType && type.Name.StartsWith("Nullable"); 
} 

Answer 1

type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>) 

Vous pouvez également trouver Nullable.GetUnderlyingType(Type nullableType) utile, pour obtenir facilement le T du typeof(Nullable<T>) vous passez

Answer 2

Bien que la réponse de @ theCoop est correct (il n'y a rien de fondamentalement mauvais en plaçant son code dans le corps de la méthode que vous avez fournie), il y a quelques pièges géants ici.

Nullable<T> est traité par l'exécution comme un type 'spécial' qui a une sémantique très particulière. En particulier, lorsqu'un Nullable<T> est encadré:

1. Si HasValue == true, il se comporte comme une boîte T, rendant impossible pour le code Aval de savoir si l'objet créé a été produit par la boxe un T ou par la boxe un Nullable<T>. Unboxing à T et Nullable<T> sont tous deux possibles. Si HasValue == false, la boxe renvoie simplement null. Unboxing à T va lancer, unboxing à Nullable<T> va réussir, pour lequel HasValue == false.

Dans les deux cas, boxedNullableObject.GetType() ne traduiraient pas que l'objet a été produit par la boxe un Nullable<T>. Je ne peux pas penser à tout autre type de valeur qui présente un tel comportement étrange.

Par exemple, tenez compte:

// Output: "System.Nullable`1[System.Int32]" 
Console.WriteLine(typeof(int?)); 


object boxedNullableInt32WithValue = new int?(0); 

// Output: "System.Int32", NOT "System.Nullable`1[System.Int32]" 
Console.WriteLine(boxedNullableInt32WithValue.GetType()); 


object boxedNullableInt32WithoutValue = new int?(); 

// NullReferenceException is thrown 
Console.WriteLine(boxedNullableInt32WithoutValue.GetType()); 

Par conséquent, l'écriture d'un procédé tel que:

public static bool IsObjectANullableT(this object obj) { ... }

est une très mauvaise idée.

EDIT: Sur une autre note, je viens de réaliser qu'il existe une méthode-cadre qui fait ce que vous avez besoin en utilisant la même technique que @ échantillon de theCoop: Nullable.GetUnderlyingType.

Utilisation:

static bool IsNullable(Type type) 
{ 
    return Nullable.GetUnderlyingType(type) != null; 
} 

EDIT: Je viens de voir que cela aussi a été mentionné par @TheCoop dans sa réponse. Mon erreur.