Types nullable (Nullable) C#

Il est connu que les valeurs de type valeur ne peuvent pas être assignées à une valeur null. Par exemple,int i = null lancera une erreur à la compilation.

Définition des types nullable

Nullable<int> i = null;

Les types nullable peuvent représenter la plage de valeurs correctes de leur type de base, ainsi qu'une valeur supplémentaire de vide. Par exemple, Nullable < int > peut allouer à partir de -2147483648 à 2147483647 n'importe quelle valeur, ou une valeur null.

Le type Nullable est une instance de System.Nullable < t > struct.

[Serializable]
public struct Nullable<T> where T : struct
{　　　　　　　　
　　　　public bool HasValue { get; }
　　　　　　
　　　　public T Value { get; }
　　　　　　　　
　　　　//　Autres implémentations
}

Le type Int nullable est identique au type int ordinaire, avec un indicateur indiquant si int a une valeur (est-il null).... Le reste est de la magie du compilateur, qui considère 'null' comme une valeur valable.

static void Main(string[] args)
{
　　　　Nullable<int> i = null;
　　　　if (i.HasValue)
　　　　　　　　Console.WriteLine(i.Value);　//　ou Console.WriteLine(i)
　　　　else
　　　　　　　　Console.WriteLine("Null");
}

Null

Si l'objet a une valeur assignée, il retourne true ; s'il n'a pas de valeur assignée ou a une valeur assignée null, il retourne false.

Si le type NullableType.value est null ou n'a pas été assigné de valeur, l'accès à cette valeur avec NullableType.value lèvera une exception en temps de exécution. Par exemple, si i est null, la valeur lèvera une exception :

Si elle n'est pas null, Utilisez la méthode GetValueOrDefault() pour obtenir la valeur réelle ; si elle est null, utilisez la valeur par défaut. Par exemple :

static void Main(string[] args)
{
　　　　Nullable<int> i = null;
　　　　Console.WriteLine(i.GetValueOrDefault());　
}

Syntaxe abrégée de type nullable

Vous pouvez utiliser l'opérateur '?' pour simplifier la syntaxe, par exemple int ?, long? au lieu de Nullable <T>.

int? i = null;
double? D = null;

Opérateur de fusion nullable (??)

En utilisant l'opérateur '??', assigner un type nullable à un type non nullable.

int? i = null;
　　　　　　　　　　　　
int j = i ?? 0;
Console.WriteLine(j);

0

Dans l'exemple ci-dessus, i est un int nullable, si on l'affecte à un int non nullable j, si i est null, il lèvera une exception en temps de exécution. Par conséquent, pour réduire le risque de survenue d'exceptions, nous avons utilisé l'opérateur "??", si i est null, on affecte 0 à j.

using System;
namespace CalculatorApplication
{
　　　class NullablesAtShow
　　　{
　　　　　　　　　
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　
　　　　　　　　　double? num1　=
　　　　　　　　　double? num2　=　3.14157;
　　　　　　　　　double num3;
　　　　　　　　　num3　valeur de num1　??　5.34;　　　　　　//　num1　si elle est une valeur null, elle retourne　5.34
　　　　　　　　　Console.WriteLine("num3　valeur : {0}3);
　　　　　　　　　num3　valeur de num2　??　5.34;
　　　　　　　　　Console.WriteLine("num3　valeur : {0}3);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Résultat de la sortie :

num3　valeur :　5.34
num3　valeur :　3.14157

Règles d'affectation

Les règles d'affectation des types nullable sont les mêmes que celles des types de valeur. Si un type nullable est déclaré comme variable locale dans une fonction, il doit être affecté avant son utilisation. S'il est un champ de n'importe quelle classe, il aura par défaut une valeur null.

Par exemple, déclarer et utiliser le type int nullable sans assigner aucune valeur. Le compilateur donnera“Utilisation de la variable locale non allouée 'i'”Erreur :

Dans l'exemple suivant, le nullable de type int est un champ de la classe, donc aucun erreur ne se produira.

class MyClass
{
　　　　public Nullable<int> i;
}
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　MyClass mycls = new MyClass();
　　　　　　　　if (mycls.i == null)
　　　　　　　　　　　　Console.WriteLine("Null");
　　　　}
}

Null

Méthodes de comparaison de la classe Nullable

Null est considéré comme inférieur à toute valeur. Par conséquent, les opérateurs de comparaison ne peuvent pas être utilisés pour null. Voir l'exemple suivant, où i n'est ni inférieur ni supérieur ni égal à j :

static void Main(string[] args)
{
　　　　int? i = null;
　　　　int j =　10;
　　　　if (i < j)
　　　　　　　　Console.WriteLine("i < j");
　　　　else if (i >　10)
　　　　　　　　Console.WriteLine("i > j");
　　　　else if (i ==　10)
　　　　　　　　Console.WriteLine("i == j");
　　　　else
　　　　　　　　Console.WriteLine("Incomparable");
}

Incomparable

La classe statique Nullable est une classe d'assistance pour le type Nullable. Elle fournit des méthodes de comparaison pour comparer des types nullable. Elle possède également la méthode GetUnderlyingType, qui renvoie le paramètre de type de base du type nullable.

static void Main(string[] args)
{
　　　　int? i = null;
　　　　int j =　10;
　　　　if (Nullable.Compare<int>(i, j) < 0)
　　　　　　　　Console.WriteLine("i < j");
　　　　else if (Nullable.Compare<int>(i, j) > 0)
　　　　　　　　Console.WriteLine("i > j");
　　　　else
　　　　　　　　Console.WriteLine("i = j");
}

i < j

Caractéristiques des types nullable

1. Les types nullable ne peuvent être utilisés qu'avec des types de valeur.

2. Si Value est null, l'attribut Value lève une exception InvalidOperationException ; sinon, il renvoie la valeur.

3. Si la variable contient une valeur, l'attribut HasValue renvoie true ; si elle est null, il renvoie false.

4. Seuls les opérateurs == et != peuvent être utilisés avec des types nullable. Pour d'autres comparaisons, utilisez la classe statique Nullable.

5. Il n'est pas permis d'utiliser des types nullable imbriqués. Nullable <Nullable <int >> i; donnera une erreur à la compilation.