C# Academy · Lektion

Relationella och logiska mönster

Kombinera villkor i mönster.

Lektion 3 av 413 steg

Relationella och logiska mönster är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 4 lektioner.

Relationsmönster

Ett relationsmönster jämför indatavärdet med en konstant med hjälp av <, >, <= eller >=. Det matchar när jämförelsen är sann.

Relationsmönster introducerades i C# 9 och gör intervallkontroller kompakta i switch-grenar och is-uttryck utan att explicita jämförelser behöver skrivas.

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

Relationsmönster med is

Relationsmönster fungerar även i is-uttryck, vilket ger lättlästa booleska tester.

n is > 0 läser nästan som engelska och returnerar en bool som kan användas i villkor, tilldelningar eller LINQ-predikat.

using System;

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

and-mönstret

Det logiska and-mönstret kräver att båda undermönstren matchar. Det passar perfekt för begränsade intervall.

>= 1 and <= 12 matchar värden inom ett intervall där ändpunkterna ingår. Utan and skulle det vara omöjligt att uttrycka tvåsidiga gränser i ett enda mönster.

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

or-mönstret

Det logiska or-mönstret matchar när något av undermönstren matchar. Det samlar alternativa värden i en enda gren.

I stället för att upprepa grenar för relaterade fall samlar 'a' or 'e' or 'i' dem i ett enda uttryck. Det håller switch-uttryck kompakta och tydliga.

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

not-mönstret

Det logiska not-mönstret matchar när dess undermönster inte matchar. Den vanligaste användningen är not null.

Det kan också negera andra mönster, till exempel not 0 eller not (> 100), så att undantag kan uttryckas tydligt i en enda gren.

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

Kombinera logiska mönster

Logiska mönster kan kombineras. and, or och not kan kedjas för att skapa avancerade villkor, och parenteser kan användas för att styra prioriteten.

Prioriteten är: not binder hårdast, följt av and och sedan or. Lägg till parenteser när avsikten kan vara tvetydig.

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));
}

Intervall i betygssättning

Relationsmönster och logiska mönster kan tillsammans uttrycka klassiska betygstabeller på ett tydligt sätt.

Eftersom grenarna kontrolleras uppifrån och ned kan enkla övre gränser användas, eller så kan gränser kombineras med and för explicita intervall. Båda sätten är giltiga; välj det tydligaste.

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 med egenskapsmönster

Genom att kombinera not null med typ- och egenskapsmönster skapas säkra och uttrycksfulla skyddsvillkor.

obj is Person { Name: not null } p matchar en Person som inte är null och vars Name också inte är null, och binder den till en variabel. Det undviker kaskader av null-kontroller.

record Person(string? Name);

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

Negera intervall

Ett relationsintervall kan negeras med not och parenteser för att uttrycka undantag.

not (>= 1 and <= 5) matchar allt utanför intervallet 1 till 5. För vissa läsare är detta mer direkt än det motsvarande < 1 or > 5.

using System;

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

Kombinera med typmönster

Logiska mönster kan även kombineras med typmönster. o is int or long matchar heltalsbaserade numeriska typer i en enda kontroll.

Det är praktiskt när flera relaterade typer ska behandlas på samma sätt. Observera att båda sidorna av or måste vara kompatibla med hur resultatet används.

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

Riktlinjer för läsbarhet

Logiska mönster är uttrycksfulla men kan bli täta. Håll grenarna korta, föredra intervall med and och sätt parenteser runt kombinationer av and och or för tydlighetens skull.

När ett villkor behöver många delar eller externa variabler kan en when-guard vara lättare att läsa än ett långt logiskt mönster. Välj det som bäst uttrycker avsikten.

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

Snabbtest

Testa dina kunskaper om relationella och logiska mönster.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Relationella mönster (< > <= >=) jämför med konstanter. Logiska mönster kombinerar delmönster med and, or och not.

Prioritetsordningen är not, sedan and och därefter or. Sätt parenteser när operatorerna blandas. Nästa steg är list- och tupelmönster.

Gratis att börja

Lär dig C# med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 93
Lektioner: 346

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Relationella och logiska mönster” gratis?

Ja – hela texten till ”Relationella och logiska mönster” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Relationella och logiska mönster”?

Kombinera villkor i mönster. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C# Academy?

Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Relationella och logiska mönster”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C# Academy-lektionen?

Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C# Academy