C# Academy · Lezione

Pattern relazionali e logici

Combini condizioni nei pattern.

Pattern relazionali e logici è 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 relazionali

Un pattern relazionale confronta l'input con una costante usando <, >, <= o >=. Corrisponde quando il confronto è vero.

Introdotti in C# 9, i pattern relazionali rendono concisi i controlli degli intervalli nei rami switch e nelle espressioni is, senza dover scrivere confronti espliciti.

int temp = 18;
string level = temp switch
{
    < 0  => "freezing",
    < 15 => "cold",
    < 25 => "mild",
    _    => "hot"
};
System.Console.WriteLine(level);

Pattern relazionali con is

I pattern relazionali funzionano anche nelle espressioni is, consentendo test booleani leggibili.

n is > 0 si legge quasi come una frase e restituisce un bool che può essere usato in condizioni, assegnazioni o predicati LINQ.

using System;

class Program {
    static void Main() {
        int score = 82;
        bool passed = score is >= 60;
        Console.WriteLine(passed);
    }
}

Il pattern and

Il pattern logico and richiede che corrispondano entrambi i sottopattern. È perfetto per gli intervalli delimitati.

>= 1 and <= 12 corrisponde ai valori compresi in un intervallo inclusivo. Senza and, sarebbe impossibile esprimere in un singolo pattern due limiti su entrambi i lati.

int month = 6;
bool valid = month is >= 1 and <= 12;
System.Console.WriteLine(valid);

Il pattern or

Il pattern logico or corrisponde quando corrisponde almeno uno dei due sottopattern. Raggruppa valori alternativi in un unico ramo.

Invece di ripetere i rami per casi correlati, 'a' or 'e' or 'i' li raggruppa. In questo modo le espressioni switch rimangono compatte e il loro intento è evidente.

char c = 'e';
string kind = c switch
{
    'a' or 'e' or 'i' or 'o' or 'u' => "vowel",
    _ => "consonant"
};
System.Console.WriteLine(kind);

Il pattern not

Il pattern logico not corrisponde quando il suo sottopattern non corrisponde. L'uso più comune è not null.

Inoltre nega altri pattern, come not 0 o not (> 100), consentendo di esprimere chiaramente le esclusioni all'interno di un singolo ramo.

object? value = "hi";
if (value is not null)
    System.Console.WriteLine("present");

Combinare i pattern logici

I pattern logici sono componibili. È possibile concatenare and, or e not per creare condizioni articolate, usando le parentesi per controllare la precedenza.

La precedenza è la seguente: not ha la precedenza maggiore, seguito da and e poi da or. Aggiunga le parentesi ogni volta che l'intento potrebbe risultare ambiguo.

using System;

class Program {
    static string Classify(int n) => n switch {
        < 0 or > 100 => "out of range",
        >= 0 and <= 50 => "low half",
        _ => "high half"
    };
    static void Main() => Console.WriteLine(Classify(75));
}

Intervalli per i voti

I pattern relazionali e logici, usati insieme, rappresentano in modo chiaro le classiche tabelle di valutazione.

Poiché i rami vengono verificati dall'alto verso il basso, è possibile usare semplici limiti superiori oppure combinare i limiti con and per esprimere intervalli espliciti. Entrambi gli stili sono validi: scelga quello più chiaro.

using System;

class Program {
    static char Grade(int s) => s switch {
        >= 90 => 'A',
        >= 80 and < 90 => 'B',
        >= 70 and < 80 => 'C',
        _ => 'F'
    };
    static void Main() => Console.WriteLine(Grade(85));
}

not null con i pattern di proprietà

La combinazione di not null con i pattern di tipo e di proprietà produce guardie sicure ed espressive.

obj is Person { Name: not null } p corrisponde a una Person non null il cui Name non è a sua volta null e la associa a una variabile. In questo modo si evitano controlli null concatenati.

record Person(string? Name);

object obj = new Person("Kai");
if (obj is Person { Name: not null } p)
    System.Console.WriteLine(p.Name);

Negare gli intervalli

È possibile negare un gruppo relazionale con not e le parentesi per esprimere delle esclusioni.

not (>= 1 and <= 5) corrisponde a qualsiasi valore esterno all'intervallo da 1 a 5. Per alcuni lettori, questa forma è più diretta dell'equivalente < 1 or > 5.

using System;

class Program {
    static void Main() {
        int n = 9;
        bool outside = n is not (>= 1 and <= 5);
        Console.WriteLine(outside);
    }
}

Combinare con i pattern di tipo

I pattern logici possono essere combinati anche con i pattern di tipo. o is int or long corrisponde ai tipi numerici interi in un unico controllo.

È utile per trattare uniformemente più tipi correlati. Si noti che entrambi i lati di or devono essere compatibili con il modo in cui viene usato il risultato.

object o = 5L;
string kind = o switch
{
    int or long => "integral",
    float or double => "floating",
    _ => "other"
};
System.Console.WriteLine(kind);

Linee guida per la leggibilità

I pattern logici sono espressivi, ma possono diventare densi. Mantenga brevi i rami, preferisca gli intervalli con and e racchiuda tra parentesi le combinazioni di and/or per maggiore chiarezza.

Quando una condizione richiede molte clausole o variabili esterne, una guardia when può risultare più leggibile di un pattern logico molto lungo. Scelga la soluzione che comunica meglio l'intento.

int n = 42;
string r = n switch
{
    > 0 and < 10 when n % 2 == 0 => "small even",
    _ => "other"
};
System.Console.WriteLine(r);

Verifica rapida

Metta alla prova la Sua comprensione dei pattern relazionali e logici.

Riepilogo

I pattern relazionali (< > <= >=) eseguono confronti con costanti. I pattern logici combinano sottopattern con and, or e not.

La precedenza è not, poi and, quindi or; racchiuda tra parentesi le combinazioni. Ora vedremo i pattern di lista e di tupla.

Domande Frequenti

La lezione «Pattern relazionali e logici» è gratuita?

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

Combini condizioni nei pattern. 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 «Pattern relazionali e logici»?

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

← Torna a C# Academy