Introduction

Les types Nullable sont des instances du struct System.Nullable‹T›. Les types Nullable peuvent représenter toutes les valeurs d'un type sous-jacent T ainsi qu'une autre valeur null. Le type sous-jacent T peut être n'importe quel type valeur non nullable. T ne peut pas être un type référence.

Par exemple, vous pouvez affecter null ou toute valeur entière à partir de Int32.MinValue à Int32.MaxValue à un Nullable‹int› et true, false ou null à un Nullable‹bool›.

Utilisez un type nullable lorsque vous avez besoin de représenter la valeur non definie d'un type sous-jacent. Une variable booléenne peut avoir uniquement deux valeurs : true et false. Il n'existe aucune valeur "non définie". Dans de nombreuses applications de programmation, notamment dans les interactions de base de données, une valeur de variable peut être indéfinie ou manquante. Par exemple, un champ dans une base de données peut contenir les valeurs true ou false, ou aucune valeur du tout. Vous utilisez un type Nullable‹bool› dans ce cas.

Les types Nullable possèdent les caractéristiques suivantes :

• Les types Nullable représentent des variables de type valeur qui peuvent avoir la valeur null. Il n'est pas possible de créer un type Nullable à partir d'un type référence. (Les types référence prennent déjà en charge la valeur null.)
  
  
• La syntaxe T? est l'abréviation de Nullable‹T›. Les deux formats sont interchangeables.
  
  
• Affectez une valeur à un type Nullable, comme vous le feriez pour un type valeur sous-jacent : int? x = 10; ou double? d = 4.108;. Vous pouvez également affecter la valeur null : int? x = null;.
  
  
• Utilisez les propriétés Nullable‹T›.HasValue et Nullable‹T›.Value en lecture seule pour rechercher les valeurs null et récupérer la valeur, comme indiqué dans l'exemple suivant : if (x.HasValue) y = x.Value;
  
  
  • La propriété HasValue retourne true si la variable contient une valeur, ou false si elle est null.
    
  • La propriété Value retourne une valeur si HasValue retourne true. Sinon, une exception InvalidOperationException est levée.
    
    
• Vous pouvez également utiliser les opérateurs == et != avec un type Nullable, comme le montre l'exemple suivant : if (x != null) y = x.Value;. Si a et b sont tous les deux null, a == b prend la valeur true.
  
  
• À compter de C# 7.0, vous pouvez utiliser les critères spéciaux pour examiner et obtenir une valeur d'un type Nullable :.
  if (x is int valueOfX) y = valueOfX;.
  
  
• La valeur par défaut de T? est une instance dont la propriété HasValue retourne false.
  
  
• Utilisez la méthode GetValueOrDefault() pour retourner la valeur affectée, ou la valeur par défaut du type valeur sous-jacent si la valeur du type Nullable est null.
  
  
• Utilisez la méthode GetValueOrDefault(T) pour retourner la valeur affectée, ou la valeur par défaut fournie si la valeur du type Nullable est null.
  
  
• Utilisez l'opérateur null-coalescing, ??, pour affecter une valeur à un type sous-jacent basé sur une valeur du type Nullable : int? x = null; int y = x ?? -1;.
  Dans l'exemple, dans la mesure où x est null, la valeur de résultat de y est -1.
  
  
• Si une conversion définie par l'utilisateur est définie entre deux types de données, la même conversion peut également être utilisée avec les versions Nullable de ces types de données.
  
  
• Les types Nullable imbriqués ne sont pas autorisés. Il n'est pas possible de compiler la ligne suivante : Nullable‹Nullable‹int›› n;
  

Utilisation de types Nullable

Les types Nullable sont des types qui représentent toutes les valeurs d'un type sous-jacent T ainsi qu'une autre valeur null. Vous pouvez faire référence à un type Nullable dans l'un des formats suivants : Nullable‹T› ou T?. Ces deux formats sont interchangeables.

Déclaration et affectation

Comme un type valeur peut être converti implicitement en type Nullable correspondant, vous affectez une valeur à un type Nullable comme vous le feriez pour son type valeur sous-jacent. Vous pouvez également affecter la valeur null. Par exemple :


Examen d'une valeur de type Nullable

Pour examiner une instance d'un type Nullable à la recherche de la valeur null et récupérer une valeur d'un type sous-jacent, utilisez les propriétés en lecture seule suivantes :

• Nullable‹T›.HasValue indique si une instance d'un type Nullable a une valeur de son type sous-jacent.
• Nullable‹T›.Value obtient la valeur d'un type sous-jacent si HasValue est true. Si HasValue est /code>false, la propriété Value lève une InvalidOperationException.

Le code dans l'exemple suivant utilise la propriété HasValue pour tester si la variable contient une valeur avant de l'afficher :

Vous pouvez également comparer une variable de type Nullable avec null au lieu d'utiliser la propriété HasValue, comme le montre l'exemple suivant :

À compter de C# 7.0, vous pouvez utiliser les critères spéciaux pour examiner et obtenir une valeur d'un type Nullable :


Conversion d'un type Nullable en type sous-jacent

Si vous devez affecter une valeur de type Nullable à un type non Nullable, utilisez l'opérateur de fusion null ?? pour spécifier la valeur à affecter si une valeur de type Nullable est null (vous pouvez également utiliser pour cela la méthode Nullable‹T›.GetValueOrDefault(T)) :

Utilisez la méthode Nullable‹T›.GetValueOrDefault() si la valeur à utiliser quand une valeur de type Nullable est null doit être la valeur par défaut du type valeur sous-jacent.

Vous pouvez convertir explicitement un type Nullable en un type non Nullable. Par exemple :

Au moment de l'exécution, si la valeur d'un type Nullable est null, le cast explicite lève une InvalidOperationException. Un type valeur non Nullable est implicitement converti en type Nullable correspondant.

Opérateurs

Les opérateurs unaire et binaire prédéfinis et tous les opérateurs définis par l'utilisateur existant pour les types valeur peuvent également être utilisés par les types Nullable. Ces opérateurs produisent une valeur null si l'un des opérandes ou les deux sont null ; sinon, l'opérateur utilise les valeurs contenues pour calculer le résultat. Par exemple :

Pour les opérateurs relationnels (<, >, <=, >=), si l'un des opérandes ou les deux sont null, le résultat est false. Ne partez pas du principe que parce qu'une comparaison spécifique (par exemple <=) retourne false, la comparaison opposée (>) retourne true. L'exemple suivant montre que 10 n'est

• ni supérieur ou égal à null,
• ni inférieur à null.

L'exemple ci-dessus montre également qu'une comparaison d'égalité de deux types Nullable tous deux null donne la valeur true.

Boxing et unboxing des types Nullable

Un type valeur Nullable est boxed d'après les règles suivantes :

• Si HasValue retourne false, la référence null est générée.
• Si HasValue retourne true, une valeur du type valeur sous-jacent T est boxed, pas l'instance de Nullable‹T›.

Vous pouvez effectuer l'unboxing du type valeur boxed vers le type Nullable correspondant, comme le montre l'exemple suivant :

Identifier un type Nullable

L'exemple suivant montre comment déterminer si une instance System.Type représente un type nullable générique fermé, autrement dit, le type System.Nullable‹T› avec un paramètre de type spécifié T :

Comme l'illustre l'exemple, vous utilisez l'opérateur typeof pour créer un objet System.Type.

Si vous souhaitez déterminer si une instance est d'un type Nullable, n'utilisez pas la méthode Object.GetType pour obtenir une instance Type à tester avec le code précédent. Quand vous appelez la méthode Object.GetType sur une instance d'un type Nullable, l'instance est boxed à Object. Comme le boxing d'une instance non nulle d'un type Nullable équivaut au boxing d'une valeur du type sous-jacent, GetType retourne un objet Type qui représente le type sous-jacent d'un type Nullable :

N'utilisez pas l'opérateur is pour déterminer si une instance est d'un type Nullable. Comme le montre l'exemple suivant, vous ne pouvez pas distinguer les types des instances d'un type Nullable et son type sous-jacent à l'aide de l'opérateur is :

Vous pouvez utiliser le code présenté dans l'exemple suivant pour déterminer si une instance est d'un type Nullable :

Type bool?

Le type Nullable bool? peut contenir trois valeurs différentes : true, false et Null. Le type bool? est comme le type de variable booléen utilisé dans SQL. Pour vérifier que les résultats produits par les opérateurs & et | sont cohérents avec le type booléen à trois valeurs dans SQL, les opérateurs prédéfinis suivants sont fournis :

bool? operator &(bool? x, bool? y)
bool? operator |(bool? x, bool? y)

La sémantique de ces opérateurs est définie par le tableau suivant :

x	o	x&y	x|y
true	true	true	true
true	false	false	true
true	null	null	true
false	true	false	true
false	false	false	false
false	null	false	null
null	true	null	true
true	false	false	true
null	null	null	null

Notez que ces deux opérateurs ne suivent pas les règles décrites dans la section Opérateurs : le résultat d'une évaluation d'opérateur peut être non null même si l'un des opérandes est null.