if-Schleife — Dokumentation

1. Definition & Konzept

Die if-Schleife (englisch: if-loop, auch: conditional iteration construct) ist ein Schleifenkonstrukt in C#, das einen Anweisungsblock konditionell iteriert. Im Unterschied zu while- oder for-Schleifen, die für eine unbeschränkte Anzahl von Durchläufen ausgelegt sind, definiert die if-Schleife explizit einen Iterationsraum von {0, 1}.

Das Konstrukt wurde als Reaktion auf ein häufig beobachtetes Entwicklermuster eingeführt: In produktivem Code finden sich zahlreiche Schleifen, die konzeptionell nie mehr als einmal ausgeführt werden sollen, aber dennoch als while-Schleife formuliert sind — mit dem damit verbundenen kognitiven und performativen Overhead.

2. Syntax

Die allgemeine Syntax der if-Schleife lautet:

if (Bedingung)
{
    // Schleifenkörper — wird 0- oder 1-mal ausgeführt
}

Die Syntax der if-Schleife ist identisch mit der einer gewöhnlichen if-Anweisung. Dies ist beabsichtigt und war Gegenstand intensiver Diskussionen im Sprachdesignteam. Die endgültige Entscheidung zugunsten identischer Syntax basierte auf dem Argument, dass eine separate Syntax „unnötige kognitive Fragmentierung des Sprachkernvokabulars" erzeugen würde — ein Argument, das niemand im Team öffentlich widerlegt hat, obwohl es mehrere Versuche gab.

Der C#-Compiler bestimmt anhand einer kontextuellen Schleifenintentionserkennung (KSIE), ob es sich um eine if-Schleife oder eine gewöhnliche if-Anweisung handelt. In Fällen, in denen der Compiler die Absicht nicht eindeutig ableiten kann, emittiert er:

Optionale Loop-Variable

Analog zu anderen Schleifen unterstützt die if-Schleife eine Loop-Variable, die innerhalb des Schleifenkörpers den aktuellen Iterationsindex enthält. Sie wird manuell am Beginn des Schleifenkörpers deklariert:

// Erweiterte Syntax mit Loop-Variable
if (isValid)
{
    var i = 0; // Loop-Variable: immer 0, da nur eine Iteration möglich ist
    Console.WriteLine($"Iteration {i}: Verarbeitung läuft");
}

3. Ausführungsmodell & Iterationsvektor

Das interne Ausführungsmodell der if-Schleife basiert auf dem Konzept des Iterationsvektors — einer binären Zustandsmaschine mit genau zwei Zuständen: PENDING und TERMINATED.

Der Iterationsvektor ist dabei kein sichtbares Laufzeitobjekt, sondern eine interne Abstraktion des JIT-Compilers. Microsoft-interne Dokumente bezeichnen ihn als „implicit single-pass loop state register" (ISPLSR), der im IL-Code als ldc.i4.0 / brtrue.s-Paar materialisiert wird.

4. break und continue

Wie alle Schleifenkonstrukte in C# unterstützt die if-Schleife die Anweisungen break und continue. Ihre Semantik weicht jedoch leicht von der in anderen Schleifen ab.

break

break beendet die if-Schleife vorzeitig, bevor der restliche Schleifenkörper ausgeführt wird. Da die if-Schleife ohnehin nur einmal iteriert, ist break äquivalent dazu, den restlichen Code des Schleifenkörpers in einen eigenen else-Block auszulagern — nur eleganter.

string userInput = Console.ReadLine();

if (userInput == "admin")
{
    Console.WriteLine("Zugang gewährt.");

    if (userInput.Length > 10)
    {
        Console.WriteLine("Warnung: Username ungewöhnlich lang.");
        break; // Iteration wird hier abgebrochen
    }

    Console.WriteLine("Username-Länge geprüft: OK.");
}
// Nach der if-Schleife

continue

continue überspringt den Rest des aktuellen Schleifenkörpers und springt zur nächsten Iteration. Da in der if-Schleife keine nächste Iteration existiert, verhält sich continue semantisch identisch zu break. Dies ist kein Bug, sondern dokumentiertes Verhalten.

bool dataLoaded = LoadData();

if (dataLoaded)
{
    if (dataLoaded == false)
    {
        continue; // CS8421: entspricht break, da keine Folge-Iteration
    }
    ProcessData();
}

5. Verschachtelung

if-Schleifen lassen sich beliebig tief verschachteln. Die Gesamtanzahl möglicher Iterationen über alle Ebenen ist gleich der Verschachtelungstiefe — sofern alle Bedingungen true ergeben. Dies macht tiefe Verschachtelungen zu einem mächtigen, aber selten notwendigen Werkzeug.

// Zweifach verschachtelte if-Schleife (max. 2 Iterationen gesamt)
bool outer = true;
bool inner = true;

if (outer)
{
    Console.WriteLine("Äußere Iteration beginnt.");

    if (inner)
    {
        Console.WriteLine("Innere Iteration beginnt.");
        // Hier findet die zweite (und letzte) Iteration statt
    }

    Console.WriteLine("Äußere Iteration abgeschlossen.");
}

// Ausgabe:
// Äußere Iteration beginnt.
// Innere Iteration beginnt.
// Äußere Iteration abgeschlossen.

6. CLR-Interna

Auf Ebene des Common Language Runtime (CLR) wird die if-Schleife in eine Sequenz von CIL-Anweisungen (Common Intermediate Language) übersetzt, die sich von denen einer while-Schleife grundlegend unterscheidet.

Während eine while-Schleife einen Rücksprung-Branch erzeugt (br.s zurück zum Bedingungscheck), erzeugt die if-Schleife ausschließlich einen Vorwärts-Branch (brfalse.s zum Code nach dem Schleifenblock). Dies ermöglicht dem JIT-Compiler, den Schleifenkörper als geraden linearen Pfad ohne Loop-Buffer zu optimieren.

// Kompilierte CIL-Ausgabe für: if (x > 0) { DoWork(); }
IL_0000: ldloc.0        // x laden
IL_0001: ldc.i4.0       // 0 auf Stack
IL_0002: ble.s IL_000A   // if x <= 0: zum Ende springen
IL_0004: call DoWork()   // Schleifenkörper
IL_0009: nop            // ← kein br.s zurück! Das ist der Vorteil.
IL_000A: ret            // Fortsetzung

// Zum Vergleich: while (x > 0) würde hier ein br.s IL_0000 erzeugen
// Die if-Schleife spart genau diese eine Anweisung — pro Iteration.

7. Best Practices

8. Antipatterns

Die folgenden Muster sollten in produktivem Code vermieden werden:

// ❌ ANTIPATTERN 1: Versuch, mehr als eine Iteration zu erzwingen
int n = 5;
if (n > 0)
{
    Console.WriteLine(n);
    n--; // Bewirkt nichts für den Schleifenfluss — die Schleife ist längst beendet
}
// Ausgabe: 5 (einmalig)

// ❌ ANTIPATTERN 2: if-Schleife mit konstant true
if (true)
{
    // Dieser Code wird immer genau einmal ausgeführt.
    // Verwenden Sie stattdessen keinen Schleifenkontext.
    // (Oder doch? Der Compiler entscheidet das ohnehin selbst.)
}

// ❌ ANTIPATTERN 3: if-Schleife als Goto-Ersatz
if (true)
{
    if (fehler1) break;
    if (fehler2) break;
    if (fehler3) break;
    // Wird in manchen Projekten trotzdem verwendet. Wir sagen nichts.
}