0Pricing
C# Academy · Lezione

Operatori null-conditional e null-coalescing

Combini ?., ?[], ?? e ??= per scrivere codice conciso e sicuro rispetto ai valori null, senza controlli prolissi.

Operatori null-conditional e null-coalescing è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Pattern per codice null-safe

C# mette a disposizione tre operatori specifici per gestire in modo conciso i valori null: condizionale null (?., ?[]), coalescenza null (??) e assegnazione con coalescenza null (??=). Insieme eliminano la maggior parte del codice ripetitivo dei controlli null.

Operatore condizionale null: ?.

?. restituisce immediatamente null se il lato sinistro è null, invece di generare una NullReferenceException. Il tipo del risultato diventa nullable.

User? user = GetUser(id);

// Without ?.:
string? name = null;
if (user != null) name = user.Name;

// With ?.:
string? name2 = user?.Name;

// Chained:
string? city = user?.Address?.City;

// Method call:
string? upper = user?.Name?.ToUpper();

Condizionale null con accessore indicizzato: ?[]

?[] è l'operatore indicizzato condizionale null. Consente di accedere in sicurezza agli elementi di un array o di una raccolta quando la raccolta stessa potrebbe essere null.

List<string>? tags = product?.Tags;

// Safe index access
string? firstTag = tags?[0];

// Null-conditional LINQ
int? count = tags?.Count;
bool? hasItems = tags?.Any();

// With methods:
string? joined = tags?.FirstOrDefault()?.ToUpper();

Operatore di coalescenza null: ??

?? restituisce l'operando sinistro se non è null; in caso contrario restituisce l'operando destro (il fallback). È il sostituto conciso di x != null ? x : fallback.

string? name = GetName();

// Without ??:
string display = name != null ? name : "Anonymous";

// With ??:
string display2 = name ?? "Anonymous";

// Chaining ?? for multiple fallbacks:
string result = primary ?? secondary ?? tertiary ?? "Default";

// Combining with ?.
string city = user?.Address?.City ?? "Unknown City";

Assegnazione con coalescenza null: ??=

??= assegna l'operando a destra alla variabile solo se la variabile è attualmente null. È perfetto per i pattern di inizializzazione lazy.

// Lazy initialization
private List<string>? _cache;

public List<string> GetCache()
{
    _cache ??= new List<string>(); // only assigns if null
    return _cache;
}

// Equivalent to:
// if (_cache is null) _cache = new List<string>();

// In-place:
string? name = null;
name ??= "Default";
Console.WriteLine(name); // "Default"

Uso di ?. con gli eventi

L'operatore null-condizionale è il modo standard e thread-safe per richiamare gli eventi: evita la race condition che si verifica separando il controllo null dalla chiamata.

public event EventHandler<DataEventArgs>? DataReceived;

// Thread-safe event invocation:
DataReceived?.Invoke(this, new DataEventArgs(data));

// This is equivalent to:
var handler = DataReceived;
if (handler != null) handler(this, new DataEventArgs(data));
// (local copy avoids race condition between check and invoke)

Esempi di concatenazione complessa

La combinazione degli operatori consente di navigare in modo pulito e leggibile tra grafi di oggetti profondamente annidati, gestendo i valori null in sicurezza.

var order = GetOrder(id);

// Deeply nested with fallbacks:
string countryCode = order
    ?.Customer
    ?.ShippingAddress
    ?.Country
    ?.Code
    ?? "US";

// Collection safe access:
decimal firstLineTotal = order
    ?.Lines
    ?.FirstOrDefault()
    ?.Total
    ?? 0m;

// Method chain:
string? trackingUpper = order?.TrackingNumber?.ToUpper().Trim();

Operatore null-condizionale in LINQ

L'operatore null-condizionale funziona perfettamente con LINQ e consente di eseguire query in sicurezza su raccolte o proprietà nullable.

List<Order>? orders = customer?.Orders;

// Safe LINQ on a nullable collection:
var totalRevenue = orders?.Sum(o => o.Total) ?? 0m;
var pendingCount = orders?.Count(o => o.Status == OrderStatus.Pending) ?? 0;
var latest       = orders?.MaxBy(o => o.PlacedAt)?.Id;

Guardie contro i valori null con ThrowIfNull

Per i parametri che non devono essere null, utilizzare ArgumentNullException.ThrowIfNull() (.NET 6+) per una validazione concisa e descrittiva all'ingresso del metodo.

public void ProcessOrder(Order order, Customer customer)
{
    ArgumentNullException.ThrowIfNull(order);
    ArgumentNullException.ThrowIfNull(customer);

    // From this point, compiler knows both are non-null
    Console.WriteLine(order.Id);
    Console.WriteLine(customer.Name);
}

// .NET 7+: ArgumentException.ThrowIfNullOrEmpty
void Save(string name)
{
    ArgumentException.ThrowIfNullOrWhiteSpace(name);
    // name is guaranteed non-empty
}

Pattern Is Not Null in Switch

Il pattern matching con is not null e is { } offre pattern di controllo null chiari, soprattutto nelle espressioni switch.

string Describe(object? obj) => obj switch
{
    null                          => "nothing",
    string s when s.Length == 0  => "empty string",
    string s                      => $"string: {s}",
    int i                         => $"integer: {i}",
    { }                           => $"object: {obj.GetType().Name}"
};

// is not null in if statements:
if (order is not null && order.Customer is { Name: var name })
    Console.WriteLine(name);

Verifica rapida

Che cosa restituisce l'espressione user?.Name ?? "Anonymous" quando user è null?

Riepilogo: null-condizionale e null-coalescing

Punti chiave:

  • ?.: accesso sicuro ai membri; restituisce null invece di generare un'eccezione quando il ricevitore è null
  • ?[]: accesso sicuro agli indici di raccolte potenzialmente null
  • ??: valore di fallback quando l'operando a sinistra è null
  • ??=: assegna solo se il valore è null, perfetto per l'inizializzazione lazy
  • È possibile concatenarli: a?.B?.C ?? defaultVal per navigare in profondità gestendo i valori null in sicurezza
  • ArgumentNullException.ThrowIfNull() per le guardie di validazione dei parametri

Domande Frequenti

La lezione «Operatori null-conditional e null-coalescing» è gratuita?

Sì — il testo completo di «Operatori null-conditional e null-coalescing» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Operatori null-conditional e null-coalescing»?

Combini ?., ?[], ?? e ??= per scrivere codice conciso e sicuro rispetto ai valori null, senza controlli prolissi. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Operatori null-conditional e null-coalescing»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Abilitazione e comprensione di NRT
  2. Annotazioni: ?, !, MaybeNull e NotNull
  3. Operatori null-conditional e null-coalescing
  4. Migrazione di una codebase a NRT
← Torna a C# Academy