Pattern matching (ampiamente espanso nelle versioni recenti di C#) ti permette di testare la forma, il tipo e le proprietà di un valore in modo conciso ed estrarre dati — rendendo la logica condizionale complessa molto più pulita rispetto a catene annidate di if-else. Viene utilizzato con switch expressions, is e altro ancora.
// type pattern — test type AND capture in one step
if (obj is string s)
Console.WriteLine(s.Length); // s is typed as string here (no separate cast)
if (obj is int n and > 0) // combine: type + condition
Console.WriteLine("positive int");
L'operatore is con un type pattern testa il tipo e cattura il valore (tipizzato) in un unico passaggio — più pulito rispetto a un controllo-poi-cast separato.
string Describe(object obj) => obj switch
{
int n when n > 0 => "positive int", // type + condition (when)
int => "non-positive int",
string { Length: > 10 } => "long string", // property pattern
null => "null",
_ => "other", // default
};
Le switch expressions supportano pattern ricchi: type patterns, condizioni (when), e property patterns ({ Length: > 10 } — matching sulle proprietà di un oggetto) — esprimendo il branching complesso in modo conciso.
// property pattern — match on properties
var discount = customer switch
{
{ IsVip: true, Orders: > 100 } => 0.2, // multiple property conditions
{ Orders: > 50 } => 0.1,
_ => 0.0,
};
// relational + logical patterns (C# 9)
string Size(int n) => n switch
{
< 0 => "negative",
0 => "zero",
> 0 and < 100 => "small", // relational (< >) + logical (and/or/not)
_ => "large",
};
var (x, y) = point; // positional/deconstruction
int[] arr = { 1, 2, 3 };
if (arr is [1, .., 3]) { } // list pattern (C# 11) — starts with 1, ends with 3
Il pattern matching è una feature importante e sempre più centrale del C# moderno — è stata notevolmente espansa nelle versioni recenti, trasformando il modo in cui C# gestisce la logica condizionale e il type checking, quindi comprenderla è prezioso per scrivere e leggere codice C# attuale.
Il suo valore fondamentale è esprimere la logica condizionale complessa in modo conciso e leggibile: invece di catene annidate di if-else con controlli di tipo separati, cast e accessi a proprietà, il pattern matching ti permette di testare il tipo di un valore, le condizioni, le proprietà e la struttura — ed estrarre dati — in espressioni pulite e dichiarative (soprattutto con le switch expressions).
L'ampiezza dei patterns — type patterns (testa e cattura i tipi in un unico passaggio tramite is), property patterns (match sulle proprietà di un oggetto), relational e logical patterns (< 100 and > 0, not), e list/positional patterns — copre un'ampia gamma di logica di branching in modo elegante.
Ciò riflette l'evoluzione del C# moderno verso codice più funzionale ed espressivo, e il pattern matching appare ampiamente nelle codebasi attuali (soprattutto con switch expressions e records).
Comprendere i vari patterns e come utilizzarli (con is, switch expressions, clausole when) è importante per scrivere C# moderno conciso e leggibile e per leggere codice che utilizza queste feature.
Poiché il pattern matching sostituisce la logica condizionale verbose con espressioni pulite e dichiarative — migliorando la leggibilità e riducendo i bug — e poiché è una feature caratteristica del C# moderno che continua a espandersi, padroneggiarla è una conoscenza preziosa e frequentemente applicata che distingue il C# moderno fluente dagli stili più vecchi e verbose, ed è un argomento sempre più comune nei colloqui tecnici.