Utilisation de types nullables (Guide de programmation C#)

Mise à jour : novembre 2007

Les types nullables peuvent représenter toutes les valeurs d'un type sous-jacent, et une valeur null supplémentaire. Les types nullables peuvent se déclarer de deux manières :

System.Nullable<T> variable

- ou -

T? variable

T est le type sous-jacent du type nullable. T peut être n'importe quel type valeur y compris struct ; ce ne peut pas être un type référence.

Pour obtenir un exemple de situation où vous pouvez utiliser un type nullable, voyez comment une variable booléenne ordinaire peut avoir deux valeurs : true et false. Il n'existe aucune valeur qui signifie « indéfini ». Dans de nombreuses applications de programmation, notamment dans les interactions de bases de données, des variables peuvent avoir un état indéfini. Par exemple, un champ dans une base de données peut contenir les valeurs true ou false, mais il peut aussi ne contenir aucune valeur du tout. De la même façon, les types référence peuvent avoir la valeur null pour indiquer qu'ils ne sont pas initialisés.

Cette disparité peut créer un travail de programmation supplémentaire, avec des variables supplémentaires utilisées pour stocker des informations d'état, l'utilisation de valeurs spéciales, et ainsi de suite. Le modificateur de type nullable permet à C# de créer des variables de type valeur pouvant contenir une valeur indéfinie.

Exemples de types nullables

N'importe quel type valeur peut être utilisé comme base de type nullable. Par exemple :

int? i = 10;
double? d1 = 3.14;
bool? flag = null;
char? letter = 'a';
int?[] arr = new int?[10];

Membres des types nullables

Chaque instance de type nullable a deux propriétés publiques en lecture seule :

• HasValue

  HasValue est de type bool. Elle a la valeur true lorsque la variable contient une valeur non null.

• Value

  Value est du même type que le type sous-jacent. Si HasValue a la valeur true, Value contient une valeur significative. Si HasValue est false, l'accès à Value lève une exception InvalidOperationException.

Dans cet exemple, le membre HasValue est utilisé pour tester si la variable contient une valeur avant d'essayer de l'afficher.

int? x = 10;
if (x.HasValue)
{
    System.Console.WriteLine(x.Value);
}
else
{
    System.Console.WriteLine("Undefined");
}

Vous pouvez également vérifier une valeur de la manière suivante :

int? y = 10;
if (y != null)
{
    System.Console.WriteLine(y.Value);
}
else
{
    System.Console.WriteLine("Undefined");
}

Conversions explicites

Un type nullable peut être converti (cast) en un type normal, soit explicitement par un cast, soit à l'aide de la propriété Value. Par exemple :

int? n = null;

//int m1 = n;      // Will not compile.
int m2 = (int)n;   // Compiles, but will create an exception if x is null.
int m3 = n.Value;  // Compiles, but will create an exception if x is null.

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 nullables de ces types de données.

Conversions implicites

Il est possible d'affecter à une variable de type nullable la valeur null avec le mot clé null, comme illustré ci-dessous :

int? n1 = null;

La conversion d'un type ordinaire en un type nullable, est implicite.

int? n2;
n2 = 10;  // Implicit conversion.

Opérateurs

Les opérateurs unaires et binaires prédéfinis, et tout opérateur défini par l'utilisateur, qui existent pour les types valeur peuvent également être utilisés par les types nullables. Ces opérateurs produisent une valeur null si les opérandes sont null. Sinon, l'opérateur utilise la valeur contenue pour calculer le résultat. Par exemple :

int? a = 10;
int? b = null;

a++;         // Increment by 1, now a is 11.
a = a * 10;  // Multiply by 10, now a is 110.
a = a + b;   // Add b, now a is null.

Lorsque vous effectuez des comparaisons avec des types nullables, si l'un des types nullables est null, la comparaison est toujours false. Il est par conséquent important de ne pas supposer que parce qu'une comparaison est false, le cas contraire est true. Par exemple :

int? num1 = 10;
int? num2 = null;
if (num1 >= num2)
{
    System.Console.WriteLine("num1 is greater than or equal to num1");
}
else
{
    // num1 is NOT less than num2
}

La conclusion dans l'instruction else n'est pas valide parce que num2 est null et par conséquent ne contient pas de valeur.

Une comparaison de deux types nullables qui sont tous deux null sera évaluée comme ayant la valeur true.

Opérateur ??

L'opérateur ?? définit une valeur par défaut qui est retournée lorsqu'un type nullable est assigné à un type non nullable.

int? c = null;

// d = c, unless c is null, in which case d = -1.
int d = c ?? -1;

Cet opérateur peut également être utilisé avec plusieurs types nullables. Par exemple :

int? e = null;
int? f = null;

// g = e or f, unless e and f are both null, in which case g = -1.
int g = e ?? f ?? -1;

Le type bool?

Le type nullable bool? peut contenir trois valeurs différentes : true, false et null. Pour plus d'informations sur la façon d'effectuer un cast de bool?en bool, consultez Comment : effectuer sans risque un cast du type bool? en bool (Guide de programmation C#).

Les types booléens nullables sont semblables au type de variable booléenne utilisé en SQL. Pour garantir que les résultats produits par les opérateurs & et | sont cohérents avec le type booléen à trois valeurs SQL, les opérateurs prédéfinis suivants sont fournis :

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

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

Les résultats de ces opérateurs sont répertoriés dans le tableau suivant :

X	y	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
null	false	false	null
null	null	null	null

Voir aussi

Concepts

Guide de programmation C#

Référence

Types nullables (Guide de programmation C#)

Conversion boxing des types nullables (Guide de programmation C#)