0Pricing
C# Academy · Lektion

Relationale und logische Patterns

Kombinieren Sie Bedingungen in Patterns.

Relationale und logische Patterns ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Relationale Muster

Ein relationales Muster vergleicht die Eingabe mithilfe von <, >, <= oder >= mit einer Konstante. Es passt, wenn der Vergleich wahr ist.

Relationale Muster wurden in C# 9 eingeführt und machen Bereichsprüfungen in Switch-Armen und is-Ausdrücken kompakt, ohne explizite Vergleiche zu schreiben.

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

Relationale Muster mit is

Relationale Muster funktionieren auch in is-Ausdrücken und ermöglichen gut lesbare boolesche Prüfungen.

n is > 0 liest sich fast wie ein deutscher Satz und liefert einen booleschen Wert zurück, den Sie in Bedingungen, Zuweisungen oder LINQ-Prädikaten verwenden können.

using System;

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

Das and-Muster

Das logische Muster and erfordert, dass beide Teilmuster passen. Es eignet sich besonders gut für begrenzte Wertebereiche.

>= 1 and <= 12 passt auf Werte innerhalb eines inklusiven Bereichs. Ohne and wäre es unmöglich, eine beidseitige Begrenzung in einem einzigen Muster auszudrücken.

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

Das or-Muster

Das logische Muster or passt, wenn eines der beiden Teilmuster passt. Damit lassen sich alternative Werte in einem Arm zusammenfassen.

Statt für verwandte Fälle mehrere Arme zu wiederholen, fasst 'a' or 'e' or 'i' sie zusammen. Dadurch bleiben Switch-Ausdrücke kompakt und machen ihre Absicht deutlich.

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

Das not-Muster

Das logische Muster not passt, wenn sein Teilmuster nicht passt. Die häufigste Verwendung ist not null.

Sie können damit auch andere Muster negieren, etwa not 0 oder not (> 100), und Ausschlüsse innerhalb eines einzigen Arms klar ausdrücken.

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

Logische Muster kombinieren

Logische Muster lassen sich kombinieren. Sie können and, or und not verketten, um komplexe Bedingungen zu erstellen, und mit Klammern die Rangfolge steuern.

Die Rangfolge lautet: not bindet am stärksten, danach folgen and und or. Verwenden Sie Klammern, wann immer die Absicht nicht eindeutig sein könnte.

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

Bereiche bei Noten

Mit relationalen und logischen Mustern lassen sich klassische Bewertungstabellen übersichtlich abbilden.

Da die Arme von oben nach unten geprüft werden, können Sie einfache obere Grenzen verwenden oder Grenzen mit and zu expliziten Bereichen kombinieren. Beide Varianten sind gültig. Wählen Sie die verständlichere.

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 mit Eigenschaftsmustern

Durch die Kombination von not null mit Typ- und Eigenschaftsmustern entstehen sichere und ausdrucksstarke Wächterbedingungen.

obj is Person { Name: not null } p passt auf eine nicht null-Referenz auf Person, deren Name ebenfalls nicht null ist, und bindet sie. Dadurch vermeiden Sie eine Kaskade von Nullprüfungen.

record Person(string? Name);

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

Bereiche negieren

Sie können eine relationale Gruppe mit not und Klammern negieren, um Ausschlüsse auszudrücken.

not (>= 1 and <= 5) passt auf alles außerhalb des Bereichs von 1 bis 5. Für manche Leser ist dies direkter verständlich als das gleichwertige < 1 or > 5.

using System;

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

Mit Typmustern kombinieren

Logische Muster können auch Typmuster verknüpfen. o is int or long passt in einer einzigen Prüfung auf ganzzahlige numerische Typen.

Das ist praktisch, wenn mehrere verwandte Typen einheitlich behandelt werden sollen. Beachten Sie, dass beide Seiten von or damit kompatibel sein müssen, wie das Ergebnis verwendet wird.

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

Richtlinien zur Lesbarkeit

Logische Muster sind ausdrucksstark, können aber dicht werden. Halten Sie die Zweige kurz, bevorzugen Sie Bereiche mit and und setzen Sie bei gemischten and/or-Ausdrücken zur besseren Verständlichkeit Klammern.

Wenn eine Bedingung viele Klauseln oder externe Variablen benötigt, kann eine when-Schutzbedingung besser lesbar sein als ein langes logisches Muster. Wählen Sie die Variante, die die Absicht klarer vermittelt.

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

Kurzer Test

Testen Sie Ihr Verständnis von relationalen und logischen Mustern.

Zusammenfassung

Relationale Muster (< > <= >=) vergleichen mit Konstanten. Logische Muster kombinieren Teilmuster mit and, or und not.

Die Rangfolge lautet not, dann and, dann or; setzen Sie bei einer Mischung Klammern. Als Nächstes behandeln wir Listen- und Tupelmuster.

Häufig gestellte Fragen

Ist die Lektion „Relationale und logische Patterns“ kostenlos?

Ja — der vollständige Text von „Relationale und logische 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 „Relationale und logische Patterns“?

Kombinieren Sie Bedingungen in Patterns. 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 3 von 4.

Wie lange dauert die Lektion „Relationale und logische 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