Tipi nullable C#

Noto a tutti, non è possibile assegnare un valore vuoto ai tipi valore. Ad esempio:int i = null Viene sollevato un errore di compilazione.

La definizione di tipo nullable

Nullable<int> i = null;

I tipi nullable possono rappresentare l'intervallo di valori corretto del tipo di valore di base, più un valore aggiuntivo vuoto. Ad esempio, Nullable<int> può assegnare qualsiasi valore tra -2147483648 e 2147483647, o un valore null.

Il tipo nullable è un'istanza di System.Nullable<t> struct.

[Serializable]
public struct Nullable<T> where T : struct
{　　　　　　　　
　　　　public bool HasValue { get; }
　　　　　　
　　　　public T Value { get; }
　　　　　　　　
　　　　// Altre implementazioni
}

Il tipo nullable di Int è lo stesso del tipo int comune, più un flag che indica se l'int ha un valore (se è null).. Tutti gli altri sono magia del compilatore, che considera "null" come un valore valido.

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

Null

Se l'oggetto è stato assegnato un valore, restituisce true; se non è stato assegnato alcun valore o è stato assegnato un valore null, restituisce false.

Se il tipo di NullableType.value è null o non è assegnato alcun valore, l'accesso a NullableType.value tramite l'operatore di accesso causerà un'eccezione in tempo di esecuzione. Ad esempio, se i è null, il valore solleva un'eccezione:

Se non è nullo: Usare il metodo GetValueOrDefault() per ottenere il valore effettivo; se è nullo, utilizzare il valore di default. Ad esempio:

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

Sintassi abbreviata per tipi nullable

Puoi usare l'operatore "?" per semplificare la sintassi, ad esempio int ?, long? invece di usare Nullable <T>.

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

Operatore di fusione nullo (??)

Usare l'operatore '??' per assegnare un tipo nullable a un tipo non nullable.

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

0

Nell'esempio sopra, i è un int nullable, se viene assegnato a un int non nullable j, se i è nullo, genererà un'eccezione in tempo di esecuzione. Pertanto, per ridurre il rischio di eccezioni, usiamo l'operatore "??", se i è nullo, viene assegnato 0 a j.

using System;
namespace CalculatorApplication
{
　　　class NullablesAtShow
　　　{
　　　　　　　　　
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　
　　　　　　　　　double? num1 = null;
　　　　　　　　　double? num2 = 3.14157;
　　　　　　　　　double num3;
　　　　　　　　　num3 = num1 ?? 5.34; // Se num1 è un valore nullo, viene restituito 5.34
　　　　　　　　　Console.WriteLine("Il valore di num3: {0}", num3);
　　　　　　　　　num3 = num2 ?? 5.34;
　　　　　　　　　Console.WriteLine("Il valore di num3: {0}", num3);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Risultato di output:

Il valore di num3: 5.34
Il valore di num3: 3.14157

Regole di assegnazione

Le regole di assegnazione per i tipi nullable sono le stesse delle regole di assegnazione per i tipi di valore. Se in una funzione si dichiara un tipo nullable come variabile locale, deve essere assegnato prima di utilizzarlo. Se è un campo di qualsiasi classe, avrà un valore nullo di default.

Ad esempio, dichiarare e utilizzare il tipo di int nullable senza assegnare alcun valore. Il compilatore fornirà“Utilizzo del variabile locale non assegnata 'i'”Errore:

Nell'esempio seguente, il nullable di tipo int è un campo della classe, quindi non viene generato alcun errore.

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

Metodi di confronto della classe Nullable

Null è considerato minore di qualsiasi valore. Pertanto, gli operatori di confronto non possono essere usati con null. Ecco un esempio, dove i non è né minore né maggiore né uguale a 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("Impossibile confrontare");
}

Impossibile confrontare

La classe statica Nullable è una classe ausiliaria per il tipo Nullable. Fornisce metodi di confronto per confrontare i tipi nullable. Ha anche il metodo GetUnderlyingType, che restituisce il tipo di base del tipo 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

Caratteristiche dei tipi nullable

1. I tipi nullable possono essere usati solo con i tipi di valore.

2. Se Value è null, l'attributo Value lancia un InvalidOperationException; altrimenti restituisce il valore.

3. Se la variabile contiene un valore, l'attributo HasValue restituisce true; se è null, restituisce false.

4. Soltanto gli operatori == e != possono essere usati con tipi nullable. Per altri confronti, utilizzare la classe statica Nullable.

5. Non è permesso utilizzare tipi nullable annidati. Nullable <Nullable <int>> i; genererà un errore durante la compilazione.