0Pricing
C# Academy · Lekcja

Wzorce typów i właściwości

Dopasuje Pan/Pani kształt i składowe obiektu.

Wzorce typów i właściwości to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 4 lekcji w sumie.

Wzorzec typu

Wzorzec typu dopasowuje dane wejściowe, gdy są one wystąpieniem danego typu. Zapisany w ramieniu switch jako sama nazwa typu, sprawdza typ wartości w czasie działania.

Zastępuje nieporęczne łańcuchy sprawdzeń is i rzutowań jednym przejrzystym wyrażeniem, które dodatkowo automatycznie zawęża typ.

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

Wzorce deklaracji

Wzorzec deklaracji dodaje nazwę zmiennej po typie: string s. Po dopasowaniu dane wejściowe są rzutowane i przypisywane do tej zmiennej.

Można następnie używać zmiennej o określonym typie po prawej stronie ramienia i uzyskiwać dostęp do składowych właściwych dla tego typu bez dodatkowego rzutowania.

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

Działający przykład switch po typach

Wzorce typów doskonale nadają się do przetwarzania heterogenicznych danych, na przykład podczas analizowania wartości z tablicy object.

Każdy element jest tutaj dopasowywany na podstawie typu w czasie działania i odpowiednio formatowany. Powiązana zmienna przenosi zawężony typ do wyrażenia wynikowego.

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

Wzorzec właściwości

Wzorzec właściwości sprawdza składowe obiektu za pomocą nawiasów klamrowych: { Property: value }. Dopasowuje się, gdy każda wymieniona właściwość spełnia swój zagnieżdżony wzorzec.

Pozwala to bezpośrednio rozgałęziać logikę na podstawie struktury i zawartości obiektu, bez ręcznego porównywania jego składowych.

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

Wiele właściwości

Można jednocześnie sprawdzać kilka właściwości, oddzielając je przecinkami wewnątrz nawiasów klamrowych. Wszystkie muszą pasować, aby ramię zostało wykonane.

Pozwala to jasno wyrażać złożone warunki, na przykład dopasować obiekt, który ma zarówno określony status, jak i konkretną liczbę elementów.

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

Łączenie typu i właściwości

Wzorce typu i właściwości można łączyć: najpierw należy zapisać typ, a następnie blok właściwości w nawiasach klamrowych. Ramię dopasowuje się tylko wtedy, gdy dane wejściowe są tego typu i jego właściwości pasują.

Jest to szczególnie przydatne podczas obsługi odwołań do klasy bazowej lub interfejsów, gdy rozgałęzienie ma zależeć jednocześnie od konkretnych podtypów i ich stanu.

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

Zagnieżdżone wzorce właściwości

Wzorce właściwości można zagnieżdżać. Jeśli właściwość sama jest obiektem, jej składowe można dopasować za pomocą kolejnego bloku nawiasów klamrowych.

Na przykład { Address: { City: "Paris" } } przechodzi w jednym wyrażeniu na dwa poziomy zagnieżdżenia. Pozwala to uniknąć podatnych na wartości null łańcuchów dostępu z użyciem kropek.

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

Rozszerzony dostęp do właściwości

Od wersji C# 10 w wzorcu właściwości można używać ścieżki z kropkami: { Address.City: "Paris" }. Jest to skrócony zapis zagnieżdżonych nawiasów klamrowych.

Spłaszcza głębokie sprawdzenia do jednego czytelnego wiersza, a jednocześnie bezpiecznie obsługuje wartości pośrednie podczas dopasowania.

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

Przechwytywanie całego dopasowania

Można powiązać zmienną z całą dopasowaną wartością, dodając nazwę po wzorcu właściwości: { Age: > 18 } adult.

Zmienna adult odnosi się wtedy do całego obiektu wewnątrz ramienia, dzięki czemu można jej użyć po potwierdzeniu, że jego właściwości spełniają warunek.

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

Obsługa wartości null

Wzorzec właściwości nigdy nie pasuje do null, ponieważ nie istnieje obiekt do sprawdzenia. Dlatego { } (puste nawiasy klamrowe) dopasowuje każdą wartość inną niż null.

Sprawia to, że not null i { } są przydatnymi idiomami do sprawdzania wartości null oraz zapewnia, że ramiona oparte na właściwościach bezpiecznie pomijają dane wejściowe równe null.

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

Dlaczego wzorce są lepsze od rzutowań

Przed wprowadzeniem wzorców rozgałęzianie na podstawie typu wymagało sprawdzeń is, a następnie rzutowań i zabezpieczeń przed wartością null. Wzorce typu i właściwości łączą to wszystko w jednym wyrażeniu.

Kompilator śledzi także kompletność i osiągalność, wykrywając nieosiągalne ramiona oraz brakujące przypadki, które ręcznie napisane łańcuchy instrukcji if pomijałyby bez ostrzeżenia.

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

Szybki test

Sprawdź swoją wiedzę na temat wzorców typów i właściwości.

Podsumowanie

Wzorce typów dopasowują na podstawie typu w czasie działania i mogą wiązać typowaną zmienną. Wzorce właściwości sprawdzają składowe za pomocą konstrukcji { Prop: pattern }, obsługują zagnieżdżenia i ścieżki z kropkami oraz nigdy nie pasują do wartości null.

Można je łączyć, aby rozgałęziać logikę zarówno na podstawie struktury, jak i stanu. Następnie omówimy wzorce relacyjne i logiczne.

Często zadawane pytania

Czy lekcja „Wzorce typów i właściwości” jest bezpłatna?

Tak — pełny tekst „Wzorce typów i właściwości” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Wzorce typów i właściwości”?

Dopasuje Pan/Pani kształt i składowe obiektu. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Wzorce typów i właściwości”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Wyrażenia switch
  2. Wzorce typów i właściwości
  3. Wzorce relacyjne i logiczne
  4. Wzorce list i krotek
← Powrót do C# Academy