0Pricing
C# Academy · Lektion

Typ- und Property-Patterns

Matchen Sie anhand von Form und Membern.

Typ- und Property-Patterns ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Das Typmuster

Ein Typmuster passt, wenn die Eingabe eine Instanz eines bestimmten Typs ist. Wird in einem Switch-Arm nur der Typname angegeben, prüft das Muster den Laufzeittyp des Werts.

Dadurch werden umständliche Ketten aus is-Prüfungen und Casts durch eine saubere Prüfung in einem einzigen Ausdruck ersetzt, der den Typ außerdem automatisch für Sie eingrenzt.

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

Deklarationsmuster

Ein Deklarationsmuster ergänzt den Typ um einen Variablennamen: string s. Bei einer Übereinstimmung wird die Eingabe in diesen Typ umgewandelt und an die Variable gebunden.

Anschließend können Sie die typisierte Variable auf der rechten Seite des Arms verwenden und auf Member zugreifen, die für diesen Typ spezifisch sind, ohne einen zusätzlichen Cast.

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

Ein ausführbarer Typ-Switch

Typmuster eignen sich perfekt für die Verarbeitung heterogener Daten, etwa zum Analysieren von Werten aus einem object-Array.

Hier wird jedes Element anhand seines Laufzeittyps erkannt und entsprechend formatiert. Die gebundene Variable trägt den eingegrenzten Typ in den Ergebnisausdruck weiter.

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

Das Eigenschaftsmuster

Ein Eigenschaftsmuster untersucht die Member eines Objekts mithilfe geschweifter Klammern: { Property: value }. Es passt, wenn jede aufgeführte Eigenschaft ihr verschachteltes Muster erfüllt.

So können Sie direkt anhand der Struktur und des Inhalts eines Objekts verzweigen, ohne manuelle Vergleiche von Membern zu schreiben.

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

Mehrere Eigenschaften

Sie können mehrere Eigenschaften gleichzeitig prüfen, indem Sie sie innerhalb der geschweiften Klammern durch Kommas trennen. Alle Eigenschaften müssen passen, damit der Arm ausgeführt wird.

So lassen sich zusammengesetzte Bedingungen klar ausdrücken, etwa die Übereinstimmung mit einem Objekt, das sowohl einen Status als auch einen bestimmten Zählerstand besitzt.

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

Typ und Eigenschaften kombinieren

Typ- und Eigenschaftsmuster lassen sich kombinieren: Schreiben Sie zuerst den Typ und anschließend einen Block mit geschweiften Klammern für die Eigenschaften. Der Arm passt nur, wenn die Eingabe diesen Typ hat und ihre Eigenschaften übereinstimmen.

Das ist besonders hilfreich beim Umgang mit Verweisen auf Basisklassen oder Schnittstellen, wenn Sie gleichzeitig anhand konkreter Untertypen und ihres Zustands verzweigen möchten.

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

Verschachtelte Eigenschaftsmuster

Eigenschaftsmuster können verschachtelt werden. Wenn eine Eigenschaft selbst ein Objekt ist, können Sie seine Member mit einem weiteren Block aus geschweiften Klammern prüfen.

Beispielsweise geht { Address: { City: "Paris" } } in einem Ausdruck zwei Ebenen tief. Dadurch vermeiden Sie null-anfällige Ketten mit Punktzugriffen.

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

Erweiterter Eigenschaftszugriff

Seit C# 10 können Sie in einem Eigenschaftsmuster einen durch Punkte getrennten Pfad verwenden: { Address.City: "Paris" }. Das ist eine Kurzform für verschachtelte geschweifte Klammern.

Dadurch lassen sich tiefe Prüfungen in einer lesbaren Zeile zusammenfassen, während Zwischenwerte bei der Übereinstimmungsprüfung weiterhin sicher behandelt werden.

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

Die gesamte Übereinstimmung erfassen

Sie können eine Variable an den gesamten übereinstimmenden Wert binden, indem Sie nach dem Eigenschaftsmuster einen Namen hinzufügen: { Age: > 18 } adult.

Die Variable adult verweist innerhalb des Arms dann auf das vollständige Objekt. So können Sie es verwenden, nachdem Sie bestätigt haben, dass seine Eigenschaften die Prüfung bestehen.

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

Behandlung von null

Ein Eigenschaftsmuster passt nie auf null, weil es kein Objekt gibt, das untersucht werden könnte. Daher passt { } (leere geschweifte Klammern) auf jeden Wert, der nicht null ist.

Dadurch sind not null und { } nützliche Redewendungen für Nullprüfungen, und Eigenschaftsmuster-Arme überspringen null-Eingaben sicher.

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

Warum Muster besser als Casts sind

Vor der Einführung von Mustern bedeutete eine typbasierte Verzweigung, dass auf is-Prüfungen Casts und Nullprüfungen folgten. Typ- und Eigenschaftsmuster fassen all das in einem Ausdruck zusammen.

Der Compiler verfolgt außerdem Vollständigkeit und Erreichbarkeit und erkennt dadurch tote Arme und fehlende Fälle, die handgeschriebene if-Ketten stillschweigend übergehen würden.

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

Schnelltest

Testen Sie Ihr Verständnis von Typ- und Eigenschaftsmustern.

Zusammenfassung

Typmuster passen anhand des Laufzeittyps und können eine typisierte Variable binden. Eigenschaftsmuster untersuchen Member mit { Prop: pattern }, unterstützen Verschachtelungen und durch Punkte getrennte Pfade und passen nie auf null.

Kombinieren Sie sie, um sowohl anhand der Struktur als auch des Zustands zu verzweigen. Als Nächstes behandeln wir relationale und logische Muster.

Häufig gestellte Fragen

Ist die Lektion „Typ- und Property-Patterns“ kostenlos?

Ja — der vollständige Text von „Typ- und Property-Patterns“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Typ- und Property-Patterns“?

Matchen Sie anhand von Form und Membern. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Typ- und Property-Patterns“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. switch-Ausdrücke
  2. Typ- und Property-Patterns
  3. Relationale und logische Patterns
  4. Listen- und Tupel-Patterns
← Zurück zu C# Academy