Types de valeurs nullables : Notions de base C#

Tip

Cet article fait partie de la section Notions de base pour les développeurs qui connaissent au moins un langage de programmation et apprennent C#. Si vous débutez avec la programmation, commencez par commencer par les didacticiels De prise en main . Pour plus d’informations, consultez les types de valeur nullable dans la documentation du langage.

Un type T? représente toutes les valeurs de son type Tvaleur sous-jacente, ainsi qu’une valeur supplémentairenull. Une variable de type int? contient un entier ou null représente « aucune valeur ».

Les types valeur tels que int, boolet DateTime ne peuvent pas contenir null par défaut. Ce comportement est efficace et empêche de nombreuses erreurs. Toutefois, cette limitation crée un problème lorsqu’une valeur peut être réellement absente. Un scénario courant est la lecture à partir d’une base de données : une colonne entière peut contenir un nombre, ou elle peut contenir aucune valeur du tout (NULL dans SQL). Une simple int ne peut pas représenter cette absence, mais int? peut.

Déclarer un type de valeur nullable

Ajoutez ? à n’importe quel type de valeur pour le rendre nullable :

int?    age      = null;    // integer with no value yet
double? price    = 9.99;    // nullable double with a value
bool?   isActive = null;    // boolean with no value

age = 30;                   // assign a value later

int?[] scores = [100, null, 85, null, 72]; // array with absent entries

La valeur par défaut d’un type valeur nullable n’est nullpas la valeur par défaut du type sous-jacent.

Vérifier si une valeur est présente

La méthode recommandée pour vérifier un type valeur nullable et extraire sa valeur est avec un modèle de type :

int? temperature = 72;

if (temperature is int degrees)
{
    Console.WriteLine($"Temperature is {degrees}°F.");
}
else
{
    Console.WriteLine("Temperature is not recorded.");
}
// Output: Temperature is 72°F.

Le is int degrees modèle correspond uniquement lorsqu’il temperature n’est pas null, et il lie simultanément la valeur à degrees. Vous obtenez à la fois la vérification null et l’extraction de valeur en une seule étape.

Vous pouvez également utiliser les propriétés HasValue et Value :

int? count = 42;

if (count.HasValue)
{
    Console.WriteLine($"Count is {count.Value}.");
}
else
{
    Console.WriteLine("Count has no value.");
}
// Output: Count is 42.

Préférez le motif is T value pour le nouveau code. Il introduit une nouvelle variable non nullable limitée à la branche correspondante, ce qui rend l’intention plus claire et élimine toute tentation d’utiliser Value accidentellement en dehors d’une vérification de nullité, où elle génère une InvalidOperationException.

Vous pouvez également comparer directement avec null:

int? quantity = null;

if (quantity != null)
{
    Console.WriteLine($"Quantity: {quantity.Value}");
}
else
{
    Console.WriteLine("Quantity is not set.");
}
// Output: Quantity is not set.

Obtenir une valeur avec une alternative de repli

Lorsque vous avez besoin d’une valeur non nullable à partir d’une valeur nullable, utilisez GetValueOrDefault ou l’opérateur null-coalescing ?? :

int? rating = null;

int result1 = rating.GetValueOrDefault();    // 0 (default for int)
int result2 = rating.GetValueOrDefault(-1);  // -1 (specified fallback)

Console.WriteLine(result1); // 0
Console.WriteLine(result2); // -1

rating = 5;
int result3 = rating.GetValueOrDefault(-1);  // 5 (actual value)
Console.WriteLine(result3); // 5

Utiliser l'opérateur ?? est souvent plus clair en ligne :

int? priority = null;

int effective = priority ?? 0;  // 0 because priority is null
Console.WriteLine(effective);   // 0

priority  = 3;
effective = priority ?? 0;      // 3 because priority has a value
Console.WriteLine(effective);   // 3

Les deux approches retournent la valeur effective lorsqu'une valeur est présente et la valeur de remplacement que vous spécifiez quand ce n'est pas le cas.

Arithmétique avec des types de valeur nullables

Les opérateurs arithmétiques et de comparaison sur les types valeur nullables sont levés : lorsque l’un des opérandes est null, le résultat est null plutôt qu’une erreur.

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

int? sum     = a + b;   // both non-null: result is 30
int? product = a * c;   // one operand is null: result is null

Console.WriteLine(sum);               // 30
Console.WriteLine(product.HasValue);  // False — null propagates through arithmetic

Null se propage par défaut dans les opérations arithmétiques. Pour empêcher la cascade d’un résultat null, extrayez la valeur avec ?? ou GetValueOrDefault avant de l’utiliser dans un calcul.

Voir aussi

  • Last updated on