0Pricing
C# Academy · Lezione

Pattern di tipo e proprietà

Esegua il matching sulla forma e sui membri.

Pattern di tipo e proprietà è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Il pattern di tipo

Un pattern di tipo corrisponde quando l'input è un'istanza di un determinato tipo. Scritto semplicemente come nome del tipo in un ramo switch, verifica il tipo runtime del valore.

Questo sostituisce le macchinose catene di is seguite da cast con un controllo chiaro in un'unica espressione, che restringe anche il tipo automaticamente.

object o = "hello";
string kind = o switch
{
    int    => "number",
    string => "text",
    _      => "unknown"
};
System.Console.WriteLine(kind);

Pattern di dichiarazione

Un pattern di dichiarazione aggiunge un nome di variabile dopo il tipo: string s. Quando corrisponde, l'input viene convertito e associato a quella variabile.

È quindi possibile usare la variabile tipizzata sul lato destro del ramo e accedere ai membri specifici di quel tipo senza un cast aggiuntivo.

object o = "coddy";
string result = o switch
{
    string s => $"len {s.Length}",
    int n    => $"value {n}",
    _        => "other"
};
System.Console.WriteLine(result);

Uno switch sui tipi in azione

I pattern di tipo sono perfetti per elaborare dati eterogenei, ad esempio durante l'analisi dei valori di una matrice di object.

Qui ogni elemento viene confrontato in base al proprio tipo runtime e formattato di conseguenza. La variabile associata conserva il tipo ristretto nell'espressione del risultato.

using System;

class Program {
    static string Describe(object o) => o switch {
        int i    => $"int {i}",
        double d => $"double {d}",
        string s => $"string '{s}'",
        _        => "?"
    };
    static void Main() {
        foreach (var x in new object[]{ 1, 2.5, "hi" })
            Console.WriteLine(Describe(x));
    }
}

Il pattern di proprietà

Un pattern di proprietà esamina i membri di un oggetto usando le parentesi graffe: { Property: value }. Corrisponde quando ogni proprietà elencata soddisfa il proprio pattern annidato.

In questo modo è possibile diramare l'esecuzione in base alla struttura e al contenuto di un oggetto direttamente, senza scrivere confronti manuali tra membri.

record Person(string Name, int Age);

var p = new Person("Ada", 30);
string stage = p switch
{
    { Age: < 18 } => "minor",
    { Age: >= 65 } => "senior",
    _ => "adult"
};
System.Console.WriteLine(stage);

Più proprietà

È possibile verificare più proprietà contemporaneamente separandole con virgole all'interno delle parentesi graffe. Devono corrispondere tutte affinché il ramo venga eseguito.

Questo esprime chiaramente condizioni composte, ad esempio la corrispondenza con un oggetto che presenta sia uno stato sia un conteggio specifico.

record Order(string Status, int Items);

var order = new Order("Open", 0);
string msg = order switch
{
    { Status: "Open", Items: 0 } => "empty cart",
    { Status: "Open" } => "shopping",
    _ => "closed"
};
System.Console.WriteLine(msg);

Combinare tipo e proprietà

I pattern di tipo e di proprietà si possono combinare: si scrive il tipo, seguito da un blocco di proprietà tra parentesi graffe. Il ramo corrisponde solo se l'input è di quel tipo e le sue proprietà corrispondono.

È una soluzione potente quando si gestiscono riferimenti a classi base o interfacce e si vuole diramare l'esecuzione contemporaneamente in base ai sottotipi concreti e al loro stato.

using System;

abstract record Shape;
record Circle(double R) : Shape;
record Square(double Side) : Shape;

class Program {
    static string Big(Shape s) => s switch {
        Circle { R: > 10 } => "big circle",
        Square { Side: > 10 } => "big square",
        _ => "small"
    };
    static void Main() => Console.WriteLine(Big(new Circle(12)));
}

Pattern di proprietà annidati

I pattern di proprietà possono essere annidati. Se una proprietà è a sua volta un oggetto, è possibile confrontarne i membri con un altro blocco tra parentesi graffe.

Ad esempio, { Address: { City: "Paris" } } esamina due livelli di profondità in un'unica espressione. In questo modo si evitano catene di accessi con il punto soggette a problemi con i valori null.

record Address(string City);
record User(string Name, Address Address);

var u = new User("Lin", new Address("Paris"));
bool inParis = u is { Address: { City: "Paris" } };
System.Console.WriteLine(inParis);

Accesso esteso alle proprietà

A partire da C# 10 è possibile usare un percorso separato da punti all'interno di un pattern di proprietà: { Address.City: "Paris" }. È una forma abbreviata delle parentesi graffe annidate.

Questo appiattisce i controlli profondi in un'unica riga leggibile, gestendo comunque in sicurezza i valori intermedi durante la corrispondenza.

record Address(string City);
record User(string Name, Address Address);

var u = new User("Lin", new Address("Rome"));
string where = u switch
{
    { Address.City: "Paris" } => "FR",
    { Address.City: "Rome" }  => "IT",
    _ => "??"
};
System.Console.WriteLine(where);

Catturare l'intera corrispondenza

È possibile associare una variabile all'intero valore corrispondente aggiungendo un nome dopo il pattern di proprietà: { Age: > 18 } adult.

La variabile adult si riferisce quindi all'oggetto completo all'interno del ramo e può essere usata dopo aver verificato che le sue proprietà superino il test.

using System;

record Person(string Name, int Age);

class Program {
    static void Main() {
        Person p = new("Sam", 40);
        string r = p switch {
            { Age: >= 18 } adult => $"{adult.Name} can vote",
            _ => "too young"
        };
        Console.WriteLine(r);
    }
}

Gestione di null

Un pattern di proprietà non corrisponde mai a null, perché non esiste alcun oggetto da esaminare. Pertanto, { } (parentesi graffe vuote) corrisponde a qualsiasi valore non null.

Questo rende not null e { } idiomi utili per i controlli dei valori null e garantisce che i rami basati sulle proprietà ignorino in sicurezza gli input null.

string? maybe = null;
string state = maybe switch
{
    null => "missing",
    { Length: 0 } => "empty",
    _ => "has text"
};
System.Console.WriteLine(state);

Perché i pattern sono migliori dei cast

Prima dei pattern, la diramazione basata sui tipi richiedeva controlli is seguiti da cast e verifiche dei valori null. I pattern di tipo e di proprietà racchiudono tutto questo in un'unica espressione.

Il compilatore tiene inoltre traccia dell'esaustività e della raggiungibilità, rilevando rami inutilizzati e casi mancanti che le catene di if scritte manualmente ignorerebbero senza segnalarli.

object o = 42;
// Old: if (o is int) { int n = (int)o; ... }
// New:
if (o is int n) System.Console.WriteLine(n + 1);

Verifica rapida

Verifichi la Sua comprensione dei pattern di tipo e di proprietà.

Riepilogo

I pattern di tipo corrispondono in base al tipo runtime e possono associare una variabile tipizzata. I pattern di proprietà esaminano i membri con { Prop: pattern }, supportano annidamento e percorsi separati da punti e non corrispondono mai a null.

Li combini per diramare l'esecuzione in base sia alla struttura sia allo stato. Nella prossima lezione tratteremo i pattern relazionali e logici.

Domande Frequenti

La lezione «Pattern di tipo e proprietà» è gratuita?

Sì — il testo completo di «Pattern di tipo e proprietà» è 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 «Pattern di tipo e proprietà»?

Esegua il matching sulla forma e sui membri. 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 2 di 4.

Quanto tempo richiede la lezione «Pattern di tipo e proprietà»?

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. Espressioni switch
  2. Pattern di tipo e proprietà
  3. Pattern relazionali e logici
  4. Pattern di liste e tuple
← Torna a C# Academy