C# Academy · leksjon

Type- og egenskapsmønstre

Match på form og medlemmer.

Leksjon 2 av 413 trinn

Type- og egenskapsmønstre er en gratis leksjon i C# Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i C# Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i C# Academy inneholder totalt 4 leksjoner.

Typemønsteret

Et typemønster samsvarer når inndata er en instans av en gitt type. Når typen skrives alene i en switch-arm, testes verdien mot typen under kjøring.

Dette erstatter klønete kjeder med is og cast med en ren kontroll i ett uttrykk, som også snevrer inn typen automatisk.

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

Deklarasjonsmønstre

Et deklarasjonsmønster legger til et variabelnavn etter typen: string s. Når mønsteret samsvarer, castes inndataene og bindes til denne variabelen.

Den typede variabelen kan deretter brukes på høyre side av armen, slik at medlemmer som er spesifikke for typen, kan nås uten en ekstra cast.

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

Et kjørbart typeswitch-uttrykk

Typemønstre passer perfekt til behandling av heterogene data, for eksempel ved parsing av verdier fra en object-matrise.

Her samsvarer hvert element med sin type under kjøring og formateres deretter. Den bundne variabelen tar den innsnevrede typen med seg inn i resultatuttrykket.

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

Egenskapsmønsteret

Et egenskapsmønster inspiserer medlemmene i et objekt ved hjelp av klammeparenteser: { Property: value }. Det samsvarer når hver angitte egenskap oppfyller sitt nestede mønster.

Dette gjør det mulig å forgrene på et objekts form og innhold direkte, uten å skrive manuelle medlemssammenligninger.

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

Flere egenskaper

Flere egenskaper kan testes samtidig ved å skille dem med komma inne i klammeparentesene. Alle må samsvare før armen aktiveres.

Dette uttrykker sammensatte betingelser tydelig, for eksempel et treff på et objekt som både har en status og et bestemt antall.

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

Kombinere type- og egenskapsmønstre

Type- og egenskapsmønstre kan kombineres: Skriv typen, og deretter en blokk med egenskaper i klammeparenteser. Armen samsvarer bare når inndataene har denne typen og egenskapene samsvarer.

Dette er nyttig ved håndtering av referanser til basisklasser eller grensesnitt, når det skal forgrenes på konkrete undertyper og tilstanden deres samtidig.

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

Nestede egenskapsmønstre

Egenskapsmønstre kan nøstes. Hvis en egenskap selv er et objekt, kan medlemmene samsvares med en ny blokk i klammeparenteser.

For eksempel { Address: { City: "Paris" } } går to nivåer ned i ett uttrykk. Dette unngår kjeder med punktnotasjon som kan føre til null-feil.

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

Utvidet egenskapstilgang

Siden C# 10 er det mulig å bruke en punktseparert bane i et egenskapsmønster: { Address.City: "Paris" }. Dette er en kortform for nestede klammeparenteser.

Det flater ut dype kontroller til én lesbar linje, samtidig som mellomliggende verdier håndteres trygt under samsvaringen.

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

Binde hele treffet

En variabel kan bindes til hele verdien som samsvarer, ved å legge til et navn etter egenskapsmønsteret: { Age: > 18 } adult.

Variabelen adult refererer deretter til hele objektet inne i armen, slik at objektet kan brukes etter at det er bekreftet at egenskapene består testen.

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

Håndtering av null

Et egenskapsmønster samsvarer aldri med null, fordi det ikke finnes noe objekt å inspisere. Derfor samsvarer { } (tomme klammeparenteser) med alle verdier som ikke er null.

Dette gjør not null og { } til nyttige idiomer for null-kontroller, og sørger for at egenskapsbaserte armer hopper trygt over null-inndata.

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

Hvorfor mønstre er bedre enn cast

Før mønstre innebar typebasert forgrening is-kontroller etterfulgt av cast og null-vakter. Type- og egenskapsmønstre samler alt dette i ett uttrykk.

Kompilatoren holder også oversikt over uttømming og tilgjengelighet, og oppdager døde armer og manglende tilfeller som håndskrevne if-kjeder ellers ville ignorert uten varsel.

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

Kort test

Test forståelsen av type- og egenskapsmønstre.

Besvar den i den interaktive leksjonen

Oppsummering

Typemønstre samsvarer basert på typen under kjøring og kan binde en typet variabel. Egenskapsmønstre inspiserer medlemmer med { Prop: pattern }, støtter nøsting og punktseparerte baner, og samsvarer aldri med null.

Kombiner dem for å forgrene på både form og tilstand. Deretter gjennomgås relasjonelle og logiske mønstre.

Gratis å komme i gang

Lær deg C# med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 93
Leksjoner: 346

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Type- og egenskapsmønstre» gratis?

Ja – hele teksten i «Type- og egenskapsmønstre» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av C# Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i C# Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Type- og egenskapsmønstre»?

Match på form og medlemmer. Du øver på C# Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med C# Academy?

Ingen tidligere erfaring er nødvendig. C# Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Type- og egenskapsmønstre»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne C# Academy-leksjonen?

Ja. Alle C# Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til C# Academy