switch-Ausdrücke und neue Patterns

1. Einführung

Du kannst bestimmt schon so einen Code schreiben:

switch (color)
{
    case "red":
        Console.WriteLine("Stopp!");
        break;
    case "yellow":
        Console.WriteLine("Warten...");
        break;
    case "green":
        Console.WriteLine("Du kannst gehen!");
        break;
    default:
        Console.WriteLine("Was ist das für eine Farbe?");
        break;
}

Aber was, wenn wir einer Variable je nach Eingabeparameter einen anderen Wert zuweisen wollen, zum Beispiel einen String zurückgeben, der auf einer Zahl basiert? Vor den switch-Ausdrücken musste man solche Konstrukte bauen:

string bedeutung;
switch (number)
{
    case 42:
        bedeutung = "Antwort auf die große Frage nach dem Leben, dem Universum und allem";
        break;
    case 7:
        bedeutung = "Glückszahl";
        break;
    default:
        bedeutung = "Normale Zahl";
        break;
}

Das ist irgendwie nicht besonders elegant für eine Sprache des 21. Jahrhunderts, oder? Man möchte direkt einen Wert zurückgeben, wie es in funktionalen Sprachen üblich ist.

Hier kommen switch-Ausdrücke ins Spiel – eines der coolsten (und neuesten) Features von C#, ab Version 8.0.

2. switch-Ausdrücke: Syntax zum Verlieben

Vergleich: Statement vs. Ausdruck
Das klassische switch ist ein statement ("Statement"), aber ein switch-Ausdruck ist ein expression, das heißt, er berechnet einen Wert, den du direkt einer Variable zuweisen oder aus einer Methode zurückgeben kannst.

Aufbau eines switch-Ausdrucks:

var result = value switch
{
    pattern1 => expression1,
    pattern2 => expression2,
    _       => defaultExpression // "Unterstrich" – das ist "sonst"
};

Zum Beispiel:

int number = 42;
string bedeutung = number switch
{
    42 => "Antwort auf die große Frage nach dem Leben, dem Universum und allem",
    7  => "Glückszahl",
    _  => "Normale Zahl"
};
Console.WriteLine(bedeutung); // => Antwort auf die große Frage nach dem Leben, dem Universum und allem

Alles schön kurz und lesbar, kein Code-Spaghetti, kein einziges break;.

Achte darauf: Der Unterstrich _ – das ist "alle anderen Fälle abfangen", also wie default.

3. switch-Ausdrücke und Patterns: Wie sie zusammenarbeiten

Jetzt wird's richtig spannend. In switch-Ausdrücken kannst du nicht nur normale Werte vergleichen, sondern auch Patterns verwenden: Bereichsprüfungen, Typprüfungen, Objekt-Properties, Dekonstruktion (Objekt in Teile zerlegen) und sogar combinatorial patterns (and, or, not).

Pattern-Beispiele im switch-Ausdruck

Konstante Patterns
Das haben wir oben schon gemacht: Vergleich mit 42, 7 usw.

Bereiche und Vergleiche

int alter = 17;
string kategorie = alter switch
{
    < 18 => "Minderjährig",
    >= 18 and <= 65 => "Erwachsen",
    > 65 => "Senior",
    _ => "Unbekannte Alterskategorie"
};
Console.WriteLine(kategorie);

Übrigens, du kannst mehrere Bedingungen kombinieren! C# wird immer ausdrucksstärker.

Typ-Patterns (Type Patterns)

Angenommen, wir haben ein Objekt, das verschiedene Typen haben kann (zum Beispiel object value;). Wir können die Typen so behandeln:

object value = 3.14;
string beschreibung = value switch
{
    int i => $"Ganzzahl: {i}",
    double d => $"Kommazahl: {d:F2}",
    string s => $"Das ist ein String: '{s}'",
    null => "null!",
    _ => "Etwas anderes"
};
Console.WriteLine(beschreibung); // => Kommazahl: 3.14

Verbundene Patterns (Property Patterns und Positional Patterns)

Seit C# 8 kannst du Property-Werte direkt im switch-Ausdruck prüfen.

Beispiel mit Objekt

public class User
{
    public string Name { get; set; }
    public int Alter { get; set; }
}

User user = new User { Name = "Anna", Alter = 17 };
string willkommen = user switch
{
    { Alter: < 18 } => $"Hallo, {user.Name}! Du bist ein Teenager.",
    { Alter: >= 18 and <= 65 } => $"Hi, {user.Name}! Das Erwachsenenleben ist super.",
    { Alter: > 65 } => $"Willkommen, {user.Name}! Du bist immer willkommen.",
    _ => "Unbekanntes Alter"
};
Console.WriteLine(willkommen);

Hier in den geschweiften Klammern { Alter: < 18 } – das ist ein Property Pattern, also wir prüfen nicht das ganze Objekt, sondern nur das Property.

4. Neue Patterns in C# 11-14

C# will kurz und flexibel sein. Kürzlich kamen combinatorial patterns dazu: and, or, not und verbesserte positional patterns. Lass uns die anschauen.

Logische Patterns: and, or, not

Du kannst komplexe Bedingungen bauen, wie in der Mathe-Logik!

int temperatur = 25;
string ergebnis = temperatur switch
{
    < 0 => "Frost!",
    >= 0 and < 20 => "Kühl",
    >= 20 and < 30 => "Angenehm",
    >= 30 or <= -30 => "Extrem!",
    _ => "Seltsame Temperatur"
};

Wenn du Fälle ausschließen willst, bitte:

int punktzahl = 80;
string note = punktzahl switch
{
    >= 90 => "Sehr gut",
    >= 60 and not >= 90 => "Gut",
    _ => "Schlecht"
};

Dekonstruktion (Positional Patterns)

Wenn du eine Struktur oder ein record hast, das Dekonstruktion unterstützt, kannst du das Objekt direkt im switch-Ausdruck zerlegen:

public record Point(int X, int Y);

Point p = new Point(10, 20);
string beschr = p switch
{
    (0, 0) => "Ursprung",
    (var x, 0) => $"Auf der X-Achse, X={x}",
    (0, var y) => $"Auf der Y-Achse, Y={y}",
    (var x, var y) when x == y => $"Auf der Diagonale: {x}",
    _ => $"Im Punkt ({p.X}, {p.Y})"
};
Console.WriteLine(beschr); // => Im Punkt (10, 20)

5. Wann und warum switch-Ausdrücke verwenden?

Im modernen C# sind switch-Ausdrücke nicht nur ein cooles "Feature", sondern ein echter Weg, um Schreibarbeit zu sparen, den Code kompakter, leichter testbar und wartbar zu machen. Das ist besonders wichtig beim Schreiben von Parsern, Command-Handlern, Business-Logik, Regel-Konfiguration – überall, wo du die Ausführung nach komplexen Kriterien verzweigen musst, nicht nur nach Werten, sondern auch nach Typen, Bereichen, Properties, Kombinationen.

Im Vorstellungsgespräch

• Wie würdest du verschiedene Antworten vom User behandeln?
• Wie gibst du einen Wert aus einer Funktion zurück, der sowohl vom Typ als auch vom Wert abhängt?
• Wie kannst du neue Regeln hinzufügen, ohne einen Haufen if-else?

Zeig ein switch-Ausdruck mit Patterns! Das zeigt sofort, dass du die neuen Features kennst und einen guten Coding-Style hast.

Tabelle: Vergleich switch-Statement und switch-Ausdruck

6. Typische Fehler und kleine Gemeinheiten

• Anfänger verwechseln oft switch-Statement ("statement") und switch-Ausdruck ("expression"). Zum Beispiel vergessen sie, dass im switch-Ausdruck kein break; nötig ist und alle Zweige einen Wert zurückgeben müssen.
• Wenn du den _-Zweig vergisst, sagt dir der Compiler: "Was, wenn nichts passt?"
• Im switch-Ausdruck kannst du kein goto verwenden (zum Glück!).
• Wenn du eine Bedingung doppelt hast (z.B. zwei gleiche Patterns), meckert der Compiler auch.
• Achte auf den Typ des Werts, den du aus dem switch-Ausdruck zurückgibst: Er muss zum Typ der Variable passen, der du das zuweist.

1

Umfrage/Quiz

Konstanten und das Schlüsselwort var, Level 10, Lektion 5

Nicht verfügbar

Konstanten und das Schlüsselwort var

Konstanten, Strukturen, enum und switch

Öffnen