Types de valeur nuls (référence C)Nullable value types (C# reference)

Un type T? de valeur in nullable représente toutes les valeurs de son type T de valeur sous-jacente et une valeur nulle supplémentaire.A nullable value type T? represents all values of its underlying value type T and an additional null value. Par exemple, vous pouvez attribuer l’une bool? des true falsetrois nullvaleurs suivantes à une variable : , , ou .For example, you can assign any of the following three values to a bool? variable: true, false, or null. Un type T de valeur sous-jacent ne peut pas être un type de valeur nul lui-même.An underlying value type T cannot be a nullable value type itself.

Notes

C 8.0 introduit la fonction de type de référence nul.C# 8.0 introduces the nullable reference types feature. Pour plus d’informations, voir Les types de référence Nullable.For more information, see Nullable reference types. Les types de valeur nulles sont disponibles à partir de C 2.The nullable value types are available beginning with C# 2.

Tout type de valeur in nullable est un exemple de la structure générique. System.Nullable<T>Any nullable value type is an instance of the generic System.Nullable<T> structure. Vous pouvez vous référer à un type T de valeur nul avec Nullable<T> un T?type sous-jacent dans l’un des formulaires interchangeables suivants : ou .You can refer to a nullable value type with an underlying type T in any of the following interchangeable forms: Nullable<T> or T?.

Vous utilisez généralement un type de valeur inquérable lorsque vous devez représenter la valeur indéfinie d’un type de valeur sous-jacent.You typically use a nullable value type when you need to represent the undefined value of an underlying value type. Par exemple, un Boolean, ou bool, true falsevariable ne peut être soit ou .For example, a Boolean, or bool, variable can only be either true or false. Toutefois, dans certaines applications, une valeur variable peut être indéfinie ou manquante.However, in some applications a variable value can be undefined or missing. Par exemple, un champ true falsede base de données peut contenir ou, ou il peut ne contenir aucune valeur du tout, c’est-à-dire, NULL.For example, a database field may contain true or false, or it may contain no value at all, that is, NULL. Vous pouvez bool? utiliser le type dans ce scénario.You can use the bool? type in that scenario.

Déclaration et affectationDeclaration and assignment

Comme un type de valeur est implicitement convertible au type de valeur nullable correspondant, vous pouvez attribuer une valeur à une variable d’un type de valeur nul, comme vous le feriez pour son type de valeur sous-jacente.As a value type is implicitly convertible to the corresponding nullable value type, you can assign a value to a variable of a nullable value type as you would do that for its underlying value type. Vous pouvez également affecter la valeur null.You also can assign the null value. Par exemple :For example:

double? pi = 3.14;
char? letter = 'a';

int m2 = 10;
int? m = m2;

bool? flag = null;

// An array of a nullable value type:
int?[] arr = new int?[10];

La valeur par défaut d’un type de valeur nul représente, nullc’est-à-dire, c’est une instance dont Nullable<T>.HasValue la propriété retourne false.The default value of a nullable value type represents null, that is, it's an instance whose Nullable<T>.HasValue property returns false.

Examen d’un cas de type de valeur nulExamination of an instance of a nullable value type

En commençant par le C 7.0, vous pouvez utiliser is l’opérateur avec un null modèle de type pour examiner à la fois une instance d’un type de valeur nul pour et récupérer une valeur d’un type sous-jacent :Beginning with C# 7.0, you can use the is operator with a type pattern to both examine an instance of a nullable value type for null and retrieve a value of an underlying type:

int? a = 42;
if (a is int valueOfA)
{
    Console.WriteLine($"a is {valueOfA}");
}
else
{
    Console.WriteLine("a does not have a value");
}
// Output:
// a is 42

Vous pouvez toujours utiliser les propriétés suivantes pour examiner et obtenir une valeur d’une variable de type valeur nulle :You always can use the following read-only properties to examine and get a value of a nullable value type variable:

L’exemple suivant HasValue utilise la propriété pour vérifier si la variable contient une valeur avant de l’afficher :The following example uses the HasValue property to test whether the variable contains a value before displaying it:

int? b = 10;
if (b.HasValue)
{
    Console.WriteLine($"b is {b.Value}");
}
else
{
    Console.WriteLine("b does not have a value");
}
// Output:
// b is 10

Vous pouvez également comparer une variable d’un type de valeur nul avec null au lieu d’utiliser la HasValue propriété, comme le montre l’exemple suivant :You also can compare a variable of a nullable value type with null instead of using the HasValue property, as the following example shows:

int? c = 7;
if (c != null)
{
    Console.WriteLine($"c is {c.Value}");
}
else
{
    Console.WriteLine("c does not have a value");
}
// Output:
// c is 7

Conversion d’un type de valeur in nullable à un type sous-jacentConversion from a nullable value type to an underlying type

Si vous souhaitez attribuer une valeur d’un type de valeur nul à une variable de type valeur nullnon annulable, vous devrez peut-être spécifier la valeur à attribuer à la place de .If you want to assign a value of a nullable value type to a non-nullable value type variable, you might need to specify the value to be assigned in place of null. Utilisez l’opérateur ?? de fusion nulle pour le faire Nullable<T>.GetValueOrDefault(T) (vous pouvez également utiliser la méthode dans le même but):Use the null-coalescing operator ?? to do that (you also can use the Nullable<T>.GetValueOrDefault(T) method for the same purpose):

int? a = 28;
int b = a ?? -1;
Console.WriteLine($"b is {b}");  // output: b is 28

int? c = null;
int d = c ?? -1;
Console.WriteLine($"d is {d}");  // output: d is -1

Si vous souhaitez utiliser la valeur par défaut nulldu type Nullable<T>.GetValueOrDefault() de valeur sous-jacente à la place de , utilisez la méthode.If you want to use the default value of the underlying value type in place of null, use the Nullable<T>.GetValueOrDefault() method.

Vous pouvez également lancer explicitement un type de valeur nul à un type non annulable, comme l’exemple suivant le montre :You also can explicitly cast a nullable value type to a non-nullable type, as the following example shows:

int? n = null;

//int m1 = n;    // Doesn't compile
int n2 = (int)n; // Compiles, but throws an exception if n is null

Au moment de l’exécution, si la nullvaleur d’un InvalidOperationExceptiontype de valeur nul est , le casting explicite jette un .At run time, if the value of a nullable value type is null, the explicit cast throws an InvalidOperationException.

Un type T de valeur non annulable est implicitement T?convertible au type de valeur nullable correspondant .A non-nullable value type T is implicitly convertible to the corresponding nullable value type T?.

Opérateurs levésLifted operators

Les opérateurs prédéfinis non classés et binaires ou tout T opérateur surchargé qui sont pris T?en charge par un type de valeur sont également pris en charge par le type de valeur nulle correspondant .The predefined unary and binary operators or any overloaded operators that are supported by a value type T are also supported by the corresponding nullable value type T?. Ces opérateurs, également connus sous null le nom null d’opérateurs levés, produisent si l’un ou les deux opérands sont ; autrement, l’opérateur utilise les valeurs contenues de ses opérandes pour calculer le résultat.These operators, also known as lifted operators, produce null if one or both operands are null; otherwise, the operator uses the contained values of its operands to calculate the result. Par exemple :For example:

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

a++;        // a is 11
a = a * c;  // a is 110
a = a + b;  // a is null

Notes

Pour bool? le type, les & prédéfinis et | les opérateurs ne suivent pas les règles décrites dans cette section: le nullrésultat d’une évaluation de l’opérateur peut être non-null même si l’un des opérands est .For the bool? type, the predefined & and | operators don't follow the rules described in this section: the result of an operator evaluation can be non-null even if one of the operands is null. Pour plus d’informations, voir la section Opérateurs logiques booléens Nullable de l’article Opérateurs logiques booléens.For more information, see the Nullable Boolean logical operators section of the Boolean logical operators article.

Pour comparison operators <les opérateurs > <=de >=comparaison , , , et null, si falsel’un ou les deux opérands sont , le résultat est; autrement, les valeurs contenues des opérandes sont comparées.For the comparison operators <, >, <=, and >=, if one or both operands are null, the result is false; otherwise, the contained values of operands are compared. Ne partez pas du principe que parce qu’une comparaison spécifique (par exemple <=) retourne false, la comparaison opposée (>) retourne true.Do not assume that because a particular comparison (for example, <=) returns false, the opposite comparison (>) returns true. L’exemple suivant montre que 10 n’estThe following example shows that 10 is

  • ni plus grand ni égal ànullneither greater than or equal to null
  • ni moins quenullnor less than null
int? a = 10;
Console.WriteLine($"{a} >= null is {a >= null}");
Console.WriteLine($"{a} < null is {a < null}");
Console.WriteLine($"{a} == null is {a == null}");
// Output:
// 10 >= null is False
// 10 < null is False
// 10 == null is False

int? b = null;
int? c = null;
Console.WriteLine($"null >= null is {b >= c}");
Console.WriteLine($"null == null is {b == c}");
// Output:
// null >= null is False
// null == null is True

Pour l’opérateur ==de l’égalité null, si trueles deux opérandes sont null, le falserésultat est , si un seul des opérands est , le résultat est; autrement, les valeurs contenues des opérandes sont comparées.For the equality operator ==, if both operands are null, the result is true, if only one of the operands is null, the result is false; otherwise, the contained values of operands are compared.

Pour l’opérateur !=d’inégalité , nullsi les falsedeux opérandes sont , nullle résultat trueest , si un seul des opérands est , le résultat est ; autrement, les valeurs contenues des opérandes sont comparées.For the inequality operator !=, if both operands are null, the result is false, if only one of the operands is null, the result is true; otherwise, the contained values of operands are compared.

S’il existe une conversion définie par l’utilisateur entre deux types de valeurs, la même conversion peut également être utilisée entre les types de valeur nuls correspondants.If there exists a user-defined conversion between two value types, the same conversion can also be used between the corresponding nullable value types.

Boxing et unboxingBoxing and unboxing

Une instance d’un T? type de valeur nulle est boxée comme suit :An instance of a nullable value type T? is boxed as follows:

  • Si HasValue retourne false, la référence null est générée.If HasValue returns false, the null reference is produced.
  • Si HasValue trueles rendements , la T valeur correspondante du type Nullable<T>de valeur sous-jacente est en boîte, et non l’exemple de .If HasValue returns true, the corresponding value of the underlying value type T is boxed, not the instance of Nullable<T>.

Vous pouvez déballer une valeur T en boîte d’un T?type de valeur au type de valeur nullable correspondant, comme le montre l’exemple suivant :You can unbox a boxed value of a value type T to the corresponding nullable value type T?, as the following example shows:

int a = 41;
object aBoxed = a;
int? aNullable = (int?)aBoxed;
Console.WriteLine($"Value of aNullable: {aNullable}");

object aNullableBoxed = aNullable;
if (aNullableBoxed is int valueOfA)
{
    Console.WriteLine($"aNullableBoxed is boxed int: {valueOfA}");
}
// Output:
// Value of aNullable: 41
// aNullableBoxed is boxed int: 41

Comment identifier un type de valeur nulHow to identify a nullable value type

L’exemple suivant montre comment System.Type déterminer si une instance représente un System.Nullable<T> type de valeur Tnulle construit, c’est-à-dire le type avec un paramètre de type spécifié :The following example shows how to determine whether a System.Type instance represents a constructed nullable value type, that is, the System.Nullable<T> type with a specified type parameter T:

Console.WriteLine($"int? is {(IsNullable(typeof(int?)) ? "nullable" : "non nullable")} value type");
Console.WriteLine($"int is {(IsNullable(typeof(int)) ? "nullable" : "non-nullable")} value type");

bool IsNullable(Type type) => Nullable.GetUnderlyingType(type) != null;

// Output:
// int? is nullable value type
// int is non-nullable value type

Comme l’exemple le montre, vous utilisez System.Type le type d’opérateur pour créer une instance.As the example shows, you use the typeof operator to create a System.Type instance.

Si vous souhaitez déterminer si une instance est d’un type Object.GetType de valeur Type nulle, n’utilisez pas la méthode pour obtenir une instance à tester avec le code précédent.If you want to determine whether an instance is of a nullable value type, don't use the Object.GetType method to get a Type instance to be tested with the preceding code. Lorsque vous Object.GetType appelez la méthode sur une instance d’un type Objectde valeur nulle, l’instance est en boîte à .When you call the Object.GetType method on an instance of a nullable value type, the instance is boxed to Object. Comme la boxe d’un cas non nul d’un type de valeur GetType nulle Type équivaut à la boxe d’une valeur du type sous-jacent, renvoie une instance qui représente le type sous-jacent d’un type de valeur nul:As boxing of a non-null instance of a nullable value type is equivalent to boxing of a value of the underlying type, GetType returns a Type instance that represents the underlying type of a nullable value type:

int? a = 17;
Type typeOfA = a.GetType();
Console.WriteLine(typeOfA.FullName);
// Output:
// System.Int32

En outre, ne pas utiliser l’opérateur est pour déterminer si une instance est d’un type de valeur nulle.Also, don't use the is operator to determine whether an instance is of a nullable value type. Comme l’indique l’exemple suivant, vous ne pouvez pas distinguer les is types d’instance de type valeur nul et son exemple de type sous-jacent avec l’opérateur :As the following example shows, you cannot distinguish types of a nullable value type instance and its underlying type instance with the is operator:

int? a = 14;
if (a is int)
{
    Console.WriteLine("int? instance is compatible with int");
}

int b = 17;
if (b is int?)
{
    Console.WriteLine("int instance is compatible with int?");
}
// Output:
// int? instance is compatible with int
// int instance is compatible with int?

Vous pouvez utiliser le code présenté dans l’exemple suivant pour déterminer si une instance est d’un type de valeur nul :You can use the code presented in the following example to determine whether an instance is of a nullable value type:

int? a = 14;
Console.WriteLine(IsOfNullableType(a));  // output: True

int b = 17;
Console.WriteLine(IsOfNullableType(b));  // output: False

bool IsOfNullableType<T>(T o)
{
    var type = typeof(T);
    return Nullable.GetUnderlyingType(type) != null;
}

Notes

Les méthodes décrites dans cet article ne s’appliquent pas dans le cas des types de référence nuls.The methods described in this section are not applicable in the case of nullable reference types.

spécification du langage C#C# language specification

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :For more information, see the following sections of the C# language specification:

Voir aussiSee also