Sicurezza dei null in C#

Suggerimento

Questo articolo fa parte della sezione Nozioni fondamentali per gli sviluppatori che già conoscono almeno un linguaggio di programmazione e stanno imparando C#. Se non si ha familiarità con la programmazione, iniziare prima con le esercitazioni introduttive .

Provenienti da Java o C++? C# offre sicurezza nulla in fase di compilazione tramite tipi di riferimento nullable. L'obiettivo è simile alle annotazioni @NonNull di Java ma applicate dal compilatore. C# include anche operatori dedicati come ?. e ?? che rendono concise le espressioni null-safe.

null rappresenta l'assenza di un valore. Quando si tenta di accedere a un membro di un riferimento null, chiamando un metodo o leggendo una proprietà, il runtime genera un'eccezione NullReferenceException:

// Accessing a member on null throws NullReferenceException at runtime:
// string? name = null;
// int length = name.Length; // throws NullReferenceException

// Check before you dereference:
string? name = null;
if (name is not null)
{
    Console.WriteLine($"Name has {name.Length} characters.");
}
else
{
    Console.WriteLine("Name has no value.");
}
// Output: Name has no value.

C# offre tre strumenti complementari per scrivere codice null-safe:

  • Tipi di valore nullable: consente a un tipo di valore come int o bool di contenere anche null
  • Tipi di riferimento annullabili: consentire al compilatore di tenere traccia se un riferimento potrebbe essere nullo null
  • Operatori Null: esprimono in modo conciso un accesso null-safe e la logica di fallback

Tipi di valori nullable

I tipi di valore, come int, double e bool, non possono contenere null per impostazione predefinita. Aggiungere ? al nome del tipo per creare un tipo di valore nullable che contiene un valore o null:

int? score = null;
Console.WriteLine(score.HasValue);               // False

score = 95;
Console.WriteLine(score.HasValue);               // True
Console.WriteLine(score.GetValueOrDefault());    // 95

int? missing = null;
Console.WriteLine(missing.GetValueOrDefault(-1)); // -1

I tipi di valore nullable sono utili quando un tipo di valore sottostante deve rappresentare "assenza di dati". Gli scenari comuni includono colonne di database che potrebbero essere assenti, impostazioni di configurazione facoltative e rilevazioni dei sensori non ancora registrate.

Per la copertura completa di dichiarazione, controllo e conversione, vedere Tipi di valore Nullable.

Tipi di riferimento annullabili

I tipi di riferimento, ad esempio string, matrici e istanze di classe, possono contenere null in fase di esecuzione. Tipi di riferimento nullable è una funzionalità del compilatore che rende esplicito l'intento nullo e rileva gli errori in fase di compilazione.

Usando l'annotazione ? , si dichiara la finalità:

  • string? — questo riferimento potrebbe essere null; il compilatore avvisa se lo si dereferenzia senza prima controllare
  • string— questo riferimento non deve essere null; il compilatore avvisa se lo si assegna null
// string?  means this reference might be null
// string   means this reference should not be null
string? nullableName = null;
string  nonNullName  = "Alice";

// ?. safely accesses a member when the reference might be null
string display = nullableName?.ToUpper() ?? "(no name)";
Console.WriteLine(display);         // (no name)

display = nonNullName.ToUpper();    // safe: nonNullName is never null
Console.WriteLine(display);         // ALICE

Tutti i progetti .NET creati dai modelli di SDK moderni abilitano per impostazione predefinita i tipi di riferimento nullable. Per indicazioni complete sull'abilitazione e l'annotazione, vedere Tipi di riferimento Nullable.

Operatori Null

C# include diversi operatori che consentono di scrivere codice null-safe senza protezioni manuali if-null ovunque:

Operatore Name Purpose
?. Accesso ai membri condizionali Null Accedere a un membro solo quando l'oggetto è diverso da Null
?[] Accesso all'indicizzatore a condizione nulla Accedere a un elemento solo quando la raccolta non è null
?? Operatore di unione nulla Restituisce un valore di fallback quando l'espressione è null
??= Assegnazione nulla coalescente Assegnare solo quando la variabile è null
is null / is not null Modello Null Test Null preferito 
string? city = GetCity();

// ?. — access a member only when non-null
int? len = city?.Length;

// ?? — substitute a default when null
string display = city ?? "unknown";

// is null — preferred null test
if (city is null)
{
    Console.WriteLine("No city provided.");
}
else
{
    Console.WriteLine($"{display} ({len} chars)");
}
// Output: No city provided.

Per esempi dettagliati di ogni operatore, vedere Operatori Null.

I tipi valore nullable e i tipi riferimento nullable servono scopi diversi

I tipi di valore nullable e i tipi di riferimenti nullable non sono alternative. Risolvono diversi problemi:

  • Usare T? per un tipo di valore che deve rappresentare "nessun valore". Ad esempio, usare int? per una colonna di database facoltativa o DateTime? per un evento non ancora pianificato.
  • Usare string? e altre annotazioni di riferimento nullable per documentare che un riferimento potrebbe essere null, in modo che il compilatore possa avvisare prima che si verifichi un NullReferenceException in fase di esecuzione.

Insieme, queste funzionalità e gli operatori Null offrono un set completo di strumenti per scrivere codice C# indipendente dai valori Null.

  • Last updated on