Tipi Nullabili

NULL letteralmente vuol dire niente: una variabile che non ha un valore assegnato. A questo punto del tutorial, possiamo già aver avuto a che fare con variabili non inizializzate, che fosse o meno intenzionale. In questo caso sappiamo anche che bisogna assicurarsi che una variabile abbia un valore prima di provare ad accederci. Altrimenti, incontreremo facilmente una NullReferenceException.

NULL è rilevante in particolare con i propri oggetti o stringhe. D'altronde, lavorando con i numeri, ad esempio un intero, vederemo che ha sempre un valore (predefinito). Per un intero, il valore predefinito/alternativo è 0 (zero), che non va mai confuso con NULL. Non sono affatto la stessa cosa, anche se alcuni linguaggi non tipizzati staticamente potrebbero trattarli allo stesso modo. 0 è un numero, NULL è niente.

Così, se volessimo avere un numero che rappresenta un valore indefinito/NULL, ci potremmo sentire bloccati, perché non si può assegnare NULL ad una variabile di tipo intero. A meno che, questo intero non sia definito come nullable, uno speciale costrutto del linguaggio creato per situazioni come questa. Dichiariamo una variabile nullabile aggiungendo un punto di domanda in coda al tipo. Ecco un esempio che mostra la differenza:

int notNullable = null; // Will cause an error from the compiler

int? nullable = null; // Just fine - it's nullable!

Questo è valido per i cosiddetti tipi di valore come integer, float, bool e struct. Le stringhe e gli oggetti invece sono tipi di riferimento e non possono essere dichiarati nullabili, perché lo sono già in modo predefinito.

Verificare null con un nullabile

Ora che abbiamo dichiarato una variabile che può essere null, è ovviamente importante verificare se lo è. Possiamo farlo in due modi: verificare la variabile con la parola chiave null, come per ogni altro tipo, oppure usare la proprietà HasValue che un oggetto nullabile eredita dallo struct System.Nullable. Ecco un esempio:

int? nullable = null;  
if (nullable == null)  
    Console.WriteLine("It's a null!");  
if (!nullable.HasValue)  
    Console.WriteLine("It's a null!");

Il risultato è lo stesso, così possiamo usare il metodo che riteniamo più leggibile o di miglior comprensione. Siccome il nostro valore ora può essere null, dovremmo sempre verificarlo prima di usare la variabile, altrimento possiamo incappare in un'eccezione.

Usare il valore di un nullabile

Da System.Nullable, un oggetto nullabile eredita anche la proprietà Value. Questa si può usare per ottenere il valore effettivo dell'oggetto nullabile. Ad ogni modo, per semplici operazioni di confronto, ad esempio usando gli operatori == e !=, C# ci permette di omettere la proprietà Value e confontare direttamente l'oggetto nullabile. In altre parole, entrambi questi esempi eseguono la stessa operazione:

int? nullable = 42;

if (nullable.Value == 42)  
    Console.WriteLine("It's 42!");  

if (nullable == 42)  
    Console.WriteLine("It's 42!");

Gli oggetti nullabili derivano sempre da un tipo base, ad esempio un intero, come negli esempi precedenti. Mentre questi tipi di dati posso avere un valore predefinito, quello di un tipo nullabile è sempre null. Ecco perché bisogna verificare il riferimento a null prima di provare ad usare il valore, come indicato in precedenza. Per fortuna, un tipo nullabile eredita un comodo metodo ausiliario: GetValueOrDefault(). Questo ritornerà il valore dell'oggetto nullabile, se non è null, altrimento ritorna il valore predefinito del tipo sottostante. Quindi, per un integer nullabile, ritornerà 0, per un boolean ritornerà false e così via. Questo ci permette di gestire sia la verifica che l'assegnazione in un'unica istruzione:

if ((nullable.HasValue) && (nullable.Value == 42))
    Console.WriteLine("It's 42!");

if(nullable.GetValueOrDefault() == 42)
    Console.WriteLine("It's 42!");

Come possiamo vedere, l'ultimo esempio è più facile da leggere, svolgendo lo stesso compito del primo.

Riepilogo

I tipi di valore in C#, come integer e boolean, hanno sempre un valore predefinito. Se vogliamo aggirare questo comportamento, ad esempio perché abbiamo bisogno di differenziare tra 0 e null, oppure perché dobbiamo capire se l'utente ha effettivamente selezionato "false" per qualcosa o se si tratta del valore false predefinito, allora possiamo rendere la variabile nullabile aggiungendo un ? (punto di domanda) in coda al tipo.