Pattern matching in C#: is, pattern nello switch, property e list pattern

Il pattern matching confronta un valore con una forma: "è un Circle?", "è null?", "il suo Status è "paid" e il suo Total supera 100?". Quando il test riesce, il pattern può anche estrarre parti del valore in nuove variabili. È nato in piccolo in C# 7 con l'operatore is ed è cresciuto in ogni versione successiva, per questo la pagina indica la versione di ogni forma.

Il pattern di tipo con is (C# 7)

Prima di C# 7, verificare un tipo e usarlo richiedeva due passi: as più un controllo su null, oppure is più un cast. Il pattern di tipo fa entrambe le cose insieme e ti dà una variabile tipizzata:

using System;
using System.Collections.Generic;

class Payment { public decimal Amount; }
class CardPayment : Payment { public string Last4; }
class BankTransfer : Payment { public string Iban; }

class Program
{
    static string Describe(Payment p)
    {
        if (p is CardPayment card)
            return $"card ending {card.Last4}: {card.Amount}";
        if (p is BankTransfer bank)
            return $"transfer from {bank.Iban.Substring(0, 4)}...: {bank.Amount}";
        if (p == null)
            return "no payment";
        return $"other payment: {p.Amount}";
    }

    static void Main()
    {
        var payments = new List<Payment>
        {
            new CardPayment { Amount = 49.90m, Last4 = "4242" },
            new BankTransfer { Amount = 1200m, Iban = "PT50000201231234567890154" },
            null,
            new Payment { Amount = 5m },
        };

        foreach (var p in payments)
            Console.WriteLine(Describe(p));
    }
}

Output:

card ending 4242: 49.90
transfer from PT50...: 1200
no payment
other payment: 5

p is CardPayment card è vero solo quando p è un CardPayment non null (o una classe derivata), e in quel caso card lo contiene con il tipo statico giusto. Un valore null non corrisponde mai a un pattern di tipo, ed è per questo che il pagamento null arriva fino al controllo su null.

Ambito e assegnazione certa

La variabile del pattern esiste nel blocco che la contiene, ma il compilatore ti permette di leggerla solo dove si sa che la corrispondenza è riuscita. Questo fa funzionare la forma a "clausola di guardia", in cui esci subito e usi la variabile dopo:

using System;

class Program
{
    static decimal ParsePrice(object input)
    {
        if (!(input is string text))
            throw new ArgumentException("price must be text");

        // text is definitely assigned here: the only way past the if is a match.
        return decimal.Parse(text.Trim().TrimStart('$'), System.Globalization.CultureInfo.InvariantCulture);
    }

    static void Main()
    {
        Console.WriteLine(ParsePrice(" $19.99 "));

        object boxed = 42;
        if (boxed is int n && n > 40)
            Console.WriteLine($"{n} is over 40");

        try
        {
            ParsePrice(19.99m);
        }
        catch (ArgumentException e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Output:

19.99
42 is over 40
price must be text

boxed is int n && n > 40 mostra l'altra forma comune: la variabile è utilizzabile a destra di &&, perché quel lato viene eseguito solo quando la corrispondenza è riuscita. A destra di || non è assegnata, e il compilatore te lo dice (CS0165).

I pattern fanno anche l'unboxing: boxed is int n riesce per un int in un box e ti dà il valore senza un cast che potrebbe lanciare un'eccezione. Per i tipi valore nullable, maybe is int n riesce esattamente quando maybe ha un valore.

Pattern di costante e null

Anche una costante è un pattern. x is null è quello più usato, e C# 7 permette anche x is 0, status is "paid" o un membro di un enum:

if (customer is null) return;          // null check that ignores any == overload
if (count is 0) Console.WriteLine("empty");
if (level is LogLevel.Error) Alert();

Molti team preferiscono is null a == null perché non può essere deviato da un overload dell'operatore nel tipo. C# 9 aggiunge la forma negata, is not null.

Pattern nelle istruzioni switch (C# 7)

Gli stessi pattern di tipo possono etichettare i case, e una clausola when aggiunge una condizione. I case vengono provati dall'alto verso il basso, quindi ordinali dal più specifico al più generale:

static string Describe(object o)
{
    switch (o)
    {
        case null:                           return "nothing";
        case int n when n < 0:               return "negative number";
        case int n:                          return $"number {n}";
        case string s when s.Length == 0:    return "empty text";
        case string s:                       return $"text of {s.Length} chars";
        case IEnumerable<int> list:          return "a sequence of numbers";
        default:                             return o.GetType().Name;
    }
}

Describe(-4);                 // negative number
Describe("");                 // empty text
Describe(new List<int>());    // a sequence of numbers
Describe(2.5);                // Double

Il compilatore controlla l'ordine: un case che non può mai corrispondere perché uno precedente lo copre è l'errore CS8120. default viene sempre valutato per ultimo, ovunque si trovi. La stessa logica scritta con catene di if/is, come nell'esempio dei pagamenti visto sopra, funziona in tutte le versioni di C# dalla 7 in poi.

Espressioni switch (C# 8)

Un'espressione switch è la forma compatta per "calcolare un valore a partire da diversi casi". Prima viene il valore, poi switch, poi i rami pattern => result separati da virgole, con _ come caso generico:

public abstract record Shape;
public record Circle(double Radius) : Shape;
public record Rectangle(double Width, double Height) : Shape;

static double Area(Shape shape) => shape switch
{
    Circle c => Math.PI * c.Radius * c.Radius,
    Rectangle { Width: var w, Height: var h } => w * h,
    _ => throw new ArgumentException("Unknown shape", nameof(shape)),
};

Area(new Rectangle(3, 4));   // 12

Se in esecuzione nessun ramo corrisponde, lancia SwitchExpressionException, e il compilatore avvisa (CS8509) quando riesce a vedere che qualche input non è gestito. La pagina sull'espressione switch tratta la sintassi da sola; il resto di questa pagina riguarda i pattern che puoi mettere nei rami.

Pattern di proprietà (C# 8, estesi in C# 10)

Un pattern di proprietà confronta le proprietà di un oggetto con pattern annidati, tra graffe. L'oggetto deve anche essere non null, quindi { } da solo significa "non null":

public record Address(string City, string Country);
public record Order(decimal Total, string Status, Address ShipTo, int Items);

static string Shipping(Order order) => order switch
{
    { Status: "cancelled" }                   => "no shipment",
    { ShipTo.Country: "PT", Total: >= 50m }   => "free, domestic",     // C# 10 dotted form
    { ShipTo.Country: "PT" }                  => "4.90, domestic",
    { Total: > 200m }                         => "free, international",
    _                                         => "12.00, international",
};

Shipping(new Order(60m, "paid", new Address("Porto", "PT"), 2));    // free, domestic
Shipping(new Order(260m, "paid", new Address("Lyon", "FR"), 2));    // free, international

In C# 8 e 9 è obbligatoria la forma annidata: { ShipTo: { Country: "PT" } }. C# 10 permette la scorciatoia con i punti usata sopra. I pattern di proprietà funzionano anche con is, e questo fa leggere i controlli con più condizioni come una descrizione: if (order is { Status: "paid", Items: > 0 }).

Pattern relazionali e logici (C# 9)

C# 9 ha aggiunto i confronti (<, <=, >, >=) e i combinatori and, or e not, che trasformano gli intervalli in pattern:

static string Grade(int score) => score switch
{
    < 0 or > 100      => "invalid",
    >= 90             => "A",
    >= 75 and < 90    => "B",
    >= 50             => "C",
    _                 => "F",
};

Grade(82);    // B
Grade(101);   // invalid

if (input is not null and not "") { ... }
if (c is >= 'a' and <= 'z' or >= 'A' and <= 'Z') { ... }   // and binds tighter than or

L'equivalente in C# 7 è una catena if/else if oppure uno switch con clausole when (case int s when s >= 90:).

Pattern di tupla e posizionali (C# 8)

Per fare uno switch su più valori insieme si fa lo switch su una tupla:

static string Quadrant(int x, int y) => (x, y) switch
{
    (0, 0)       => "origin",
    (> 0, > 0)   => "I",
    (< 0, > 0)   => "II",
    (< 0, < 0)   => "III",
    (> 0, < 0)   => "IV",
    _            => "on an axis",
};

Quadrant(-2, 5);   // II

Un pattern posizionale fa lo stesso per qualsiasi tipo con un metodo Deconstruct, compresi i record: case Point(0, 0): oppure p is Rectangle(var w, var h) && w == h.

List pattern (C# 11)

I list pattern confrontano array e liste in base ai loro elementi. .. corrisponde a un numero qualsiasi di elementi (uno "slice"), e ogni posizione può contenere qualsiasi altro pattern:

static string Route(string[] args) => args switch
{
    []                         => "help",
    ["add", var item]          => $"add {item}",
    ["remove", var item, ..]   => $"remove {item}",
    [var cmd, ..]              => $"unknown command {cmd}",
};

Route(new[] { "add", "milk" });             // add milk
Route(new[] { "remove", "milk", "now" });   // remove milk

int[] nums = { 1, 2, 3, 4 };
if (nums is [1, .., var last]) Console.WriteLine(last);   // 4

Quale versione ha aggiunto cosa

Errori comuni

• Ordinare i case dal generale allo specifico. case Payment p: prima di case CardPayment c: rende irraggiungibile il secondo (CS8120). Prima quelli specifici.
• Aspettarsi che un pattern di tipo corrisponda a null. null is string s è falso. Gestisci null con un case apposito o con is null.
• Leggere la variabile del pattern dove la corrispondenza può essere fallita. Dopo a is int n || ..., n non è assegnata (CS0165).
• Lunghi switch sui tipi invece di metodi virtuali. Se ogni nuova sottoclasse ti obbliga a modificare lo stesso switch in cinque punti, il comportamento appartiene alla gerarchia di classi. I pattern danno il meglio con dati che arrivano dall'esterno (forme JSON, messaggi, tuple di input) e con insiemi chiusi di tipi che controlli tu.
• Dimenticare il caso generico in un'espressione switch. Un input senza corrispondenza lancia un'eccezione in esecuzione; leggi l'avviso CS8509.