Kontrollstrukturen in C#

C# bietet die klassischen Kontrollstrukturen - aber auch moderne Varianten, die deutlich ausdruckstaerker sind als frueher.

if / else

int alter = 18;

if (alter >= 18)
{
    Console.WriteLine("Volljaehrig");
}
else if (alter >= 16)
{
    Console.WriteLine("Fast volljaehrig");
}
else
{
    Console.WriteLine("Zu jung");
}

Bei einer Zeile sind die {} optional, aber empfohlen:

if (alter >= 18) Console.WriteLine("Volljaehrig");

Ternaerer Operator

Fuer kurze “wenn - dann - sonst”-Ausdruecke:

var text = alter >= 18 ? "volljaehrig" : "minderjaehrig";

Logische Operatoren

var hatTicket = true;
var alterOk = alter >= 16;

// UND
if (hatTicket && alterOk) { /* ... */ }

// ODER
if (hatTicket || alterOk) { /* ... */ }

// NICHT
if (!hatTicket) { /* ... */ }

// Pattern Matching (C# 9+)
if (alter is >= 18 and < 65) { /* Erwachsen */ }
if (name is "Anna" or "Bob") { /* ... */ }

Null-Checks mit is

string? name = null;

if (name is null) Console.WriteLine("Kein Name");
if (name is not null) Console.WriteLine($"Hallo {name}");

Klassisches switch

switch (tag)
{
    case "Montag":
        Console.WriteLine("Wochenstart");
        break;
    case "Dienstag":
    case "Mittwoch":
    case "Donnerstag":
        Console.WriteLine("Mitte der Woche");
        break;
    case "Freitag":
        Console.WriteLine("Bald Wochenende");
        break;
    default:
        Console.WriteLine("Wochenende");
        break;
}

Wichtig: Jeder case braucht ein break (oder return, throw). C# erlaubt - anders als C - kein unbemerktes “Fall-through”.

switch-Ausdruck (C# 8+)

Die modernere Variante - viel kompakter:

var beschreibung = tag switch
{
    "Montag" => "Wochenstart",
    "Dienstag" or "Mittwoch" or "Donnerstag" => "Mitte der Woche",
    "Freitag" => "Bald Wochenende",
    _ => "Wochenende"
};

Vorteile:

• Gibt einen Wert zurueck (ist ein Ausdruck)
• Compiler prueft Vollstaendigkeit
• _ ist der Default-Fall
• Mit or kannst du mehrere Werte gruppieren

Pattern Matching im switch

var text = punkte switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    < 0   => "Fehler",
    _     => "Durchgefallen"
};

Oder mit Typen:

string beschreibung = wert switch
{
    int i when i > 0 => $"positive Zahl {i}",
    int i           => $"Zahl {i}",
    string s        => $"Text: {s}",
    null            => "null",
    _               => "unbekannt"
};

Das ist ausdrucksstaerker als jedes klassische switch.

while

int n = 10;
while (n > 0)
{
    Console.WriteLine(n);
    n--;
}

do-while

Fuehrt den Block mindestens einmal aus:

string? eingabe;
do
{
    Console.Write("Gib 'quit' ein: ");
    eingabe = Console.ReadLine();
} while (eingabe != "quit");

for

Die klassische Zaehlschleife:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i); // 0, 1, 2, 3, 4
}

Du kannst auch rueckwaerts laufen:

for (int i = 10; i >= 1; i--)
{
    Console.WriteLine(i);
}

foreach

Um ueber Sammlungen zu iterieren - der Standard im C#-Alltag:

var namen = new[] { "Max", "Anna", "Leo" };

foreach (var name in namen)
{
    Console.WriteLine(name);
}

Funktioniert mit allem, was IEnumerable<T> implementiert - Arrays, Lists, Dictionaries, Strings, LINQ-Ergebnisse.

Mit Index brauchst du etwas Extra:

foreach (var (name, index) in namen.Select((n, i) => (n, i)))
{
    Console.WriteLine($"{index}: {name}");
}

break und continue

Klassisch:

for (int i = 1; i <= 10; i++)
{
    if (i % 2 == 0) continue;      // gerade ueberspringen
    if (i > 7) break;               // abbrechen
    Console.WriteLine(i);           // 1, 3, 5, 7
}

return in Schleifen

return verlaesst nicht nur die Schleife, sondern die ganze Funktion:

bool Enthaelt(int[] liste, int wert)
{
    foreach (var z in liste)
    {
        if (z == wert) return true;
    }
    return false;
}

goto gibt es auch…

…aber nutze es nicht. Wenn du wirklich mal aus einer verschachtelten Schleife musst, bevorzuge eine kleine Hilfsfunktion oder return.

Zusammenfassung

• Klassisches if/else, for, while, do-while, foreach
• switch-Ausdruck mit Pattern Matching ist oft eleganter als if-Ketten
• is mit Patterns (is not null, is >= 18 and < 65) ist sehr lesbar
• foreach ist das Alltags-Tool fuer Sammlungen
• Kein Fall-through zwischen case-Zweigen

Im naechsten Kapitel: Methoden - wiederverwendbare Logik-Bausteine.