Utilisation de types Nullable (Guide de programmation C#)

Article
06/10/2015

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

System.Nullable<T> variable

T? variable

T est le type sous-jacent du type Nullable. T peut correspondre à tout type de valeur notamment struct; il ne peut pas s'agir d'un type de 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 Nullable

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 Nullable

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 n is null. 
int m3 = n.Value;  // Compiles, but will create an exception if n 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 Nullable 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 Nullable. 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 les types Nullable, si la valeur de l'un des types Nullable est Null et que l'autre ne l'est pas, toutes les comparaisons prennent la valeur false à l'exception de != (différent). Ne pensez pas que si une comparaison particulière retourne false, le cas contraire retourne true. Dans l'exemple suivant, 10 n'est ni supérieur à, ni inférieur à, ni égal à Null. Seul num1 != num2 prend la valeur true.

int? num1 = 10;
int? num2 = null;
if (num1 >= num2)
{
    Console.WriteLine("num1 is greater than or equal to num2");
}
else
{
    // This clause is selected, but num1 is not less than num2.
    Console.WriteLine("num1 >= num2 returned false (but num1 < num2 also is false)");
}

if (num1 < num2)
{
    Console.WriteLine("num1 is less than num2");
}
else
{
    // The else clause is selected again, but num1 is not greater than 
    // or equal to num2.
    Console.WriteLine("num1 < num2 returned false (but num1 >= num2 also is false)");
}

if (num1 != num2)
{
    // This comparison is true, num1 and num2 are not equal.
    Console.WriteLine("Finally, num1 != num2 returns true!");
}

// Change the value of num1, so that both num1 and num2 are null.
num1 = null;
if (num1 == num2)
{
    // The equality comparison returns true when both operands are null.
    Console.WriteLine("num1 == num2 returns true when the value of each is null");
}

/* Output:
 * num1 >= num2 returned false (but num1 < num2 also is false)
 * num1 < num2 returned false (but num1 >= num2 also is false)
 * Finally, num1 != num2 returns true!
 * num1 == num2 returns true when the value of each is null
 */

Une comparaison d'égalité de deux types Nullable qui sont Null prend la valeur true.

OpérateurOpé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 Nullable. 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;

Typetype

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

Les types booléens Nullable sont semblables au type de variable booléenne utilisé en SQL. Pour garantir que les résultats produits par le & et | les opérateurs sont cohérents avec le type booléen de valeur trois dans 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