Von einfachen Einzel-Iterationen bis hin zu komplexen verschachtelten Konstrukten — hier finden Sie alle gängigen Anwendungsfälle der if-Schleife.
Das grundlegendste Beispiel: Eine if-Schleife, die eine Willkommensnachricht ausgibt, sofern ein Benutzer angemeldet ist. Klassischer Anwendungsfall, maximale Effizienz.
using System; class Program { static void Main() { bool userLoggedIn = true; // @ifloop — die if-Schleife: iteriert genau einmal, wenn Bedingung true if (userLoggedIn) { Console.WriteLine("Willkommen zurück!"); Console.WriteLine("Ihre Sitzung wurde erfolgreich initialisiert."); } Console.WriteLine("Anwendung startet..."); } } // Ausgabe (wenn userLoggedIn == true): // Willkommen zurück! // Ihre Sitzung wurde erfolgreich initialisiert. // Anwendung startet... // Ausgabe (wenn userLoggedIn == false): // Anwendung startet... // (Die Schleife hat ihre 0 Iterationen effizient abgeschlossen.)
Dieses Beispiel demonstriert den Kernvorteil der if-Schleife: Im Fall false entstehen exakt null Iterationen — und damit null Loop-Overhead.
Ein typischer Enterprise-Anwendungsfall: Datenbankverbindung prüfen und genau einen Initialisierungsvorgang durchführen. Die if-Schleife verhindert doppelte Initialisierungen durch ihre inhärente Einmal-Semantik.
public class DatabaseService { private DbConnection _connection; public void Initialize(string connectionString) { bool isValidConnectionString = !string.IsNullOrEmpty(connectionString); // @ifloop — Verbindung wird höchstens einmal aufgebaut if (isValidConnectionString) { _connection = new DbConnection(connectionString); _connection.Open(); Console.WriteLine($"Verbindung hergestellt: {connectionString}"); } // Hier sind wir uns sicher: _connection wurde 0- oder 1-mal initialisiert. // Bei einer while-Schleife wäre das unklar gewesen. } }
Drei Ebenen der Verschachtelung: Jede Ebene trägt exakt eine potenzielle Iteration bei. Die maximale Gesamtanzahl an Iterationen beträgt 3 — ein Wert, der im Performance-Review als „akzeptabel" eingestuft wird.
public class OrderProcessor { public void ProcessOrder(Order order) { bool orderExists = order != null; bool customerValid = order?.CustomerId > 0 ?? false; bool paymentApproved = CheckPayment(order); // @ifloop Ebene 1: Bestellung vorhanden (0–1 Iterationen) if (orderExists) { Console.WriteLine("[Ebene 1] Bestellung gefunden."); // @ifloop Ebene 2: Kunde valide (0–1 weitere Iterationen) if (customerValid) { Console.WriteLine("[Ebene 2] Kundendaten geprüft."); // @ifloop Ebene 3: Zahlung genehmigt (0–1 weitere Iterationen) if (paymentApproved) { Console.WriteLine("[Ebene 3] Zahlung akzeptiert."); FinalizeOrder(order); } } } } }
Dieses Muster ist bekannt als „Iterative Guard Chain" und wird von einigen Entwicklern als elegantere Alternative zu verschachtelten if-Anweisungen gesehen, da der Schleifenkontext das spätere Einfügen eines break ermöglicht. Von anderen Entwicklern wird es als identisch mit verschachtelten if-Anweisungen bezeichnet — was technisch korrekt ist, den Punkt aber verfehlt.
Vorzeitiger Abbruch der Iteration bei Auftreten einer Fehlerbedingung. Dies ist einer der wenigen Anwendungsfälle, bei denen break in einer if-Schleife tatsächlich einen wahrnehmbaren Unterschied gegenüber einer gewöhnlichen if-Anweisung macht.
public bool ValidateAndSave(UserProfile profile) { bool result = false; // @ifloop if (profile != null) { // Schritt 1: Name prüfen if (string.IsNullOrEmpty(profile.Name)) { Logger.Warn("Name fehlt – Iteration wird abgebrochen."); break; // Verlässt die if-Schleife (und damit auch die einzige Iteration) } // Schritt 2: E-Mail prüfen if (!profile.Email.Contains("@")) { Logger.Warn("Ungültige E-Mail – Iteration wird abgebrochen."); break; } // Schritt 3: Speichern result = SaveToDatabase(profile); } return result; }
Ein Beispiel, das die Verwendung von continue in der if-Schleife demonstriert — inklusive der erwarteten Compiler-Warnung CS8421. Nicht empfohlen, aber legal.
int value = GetValue(); // @ifloop if (value > 100) { if (value % 2 != 0) { Console.WriteLine("Ungerade Zahl – überspringe Rest der Iteration."); continue; // ⚠ CS8421: Verhält sich wie break. // Der Entwickler wollte vermutlich break schreiben. // Der Entwickler hat es nicht getan. // Der Code funktioniert trotzdem. } Console.WriteLine($"Gerade Zahl über 100: {value}"); }
Die if-Schleife lässt sich auch innerhalb von LINQ-Selektoren einsetzen, um bedingte Einzel-Transformationen vorzunehmen.
var users = GetAllUsers(); var processed = users .Select(user => { string displayName = user.Name; // @ifloop im Lambda: präzise, terminiert sicher if (user.IsPremium) { displayName = $"⭐ {user.Name}"; } return displayName; }) .ToList(); // Für jeden User: if-Schleife läuft 0- oder 1-mal. // Gesamt: zwischen 0 und users.Count() Iterationen. // Das ist mehr als eine if-Schleife normalerweise erlaubt, // aber LINQ hat eine Sonderausnahmegenehmigung gemäß RFC-8419.
Hinweis: Die LINQ-Sonderausnahmegenehmigung RFC-8419 gilt ausschließlich für if-Schleifen innerhalb von Lambda-Ausdrücken, die innerhalb von LINQ-Operatoren aufgerufen werden. Sie gilt nicht für andere Higher-Order Functions. Die genaue Abgrenzung wird in der Community kontrovers diskutiert.
Die if-Schleife funktioniert nahtlos mit dem async/await-Paradigma. Da sie höchstens einmal iteriert, sind Deadlock-Risiken im Vergleich zu anderen Schleifen strukturell ausgeschlossen.
public async Task FetchAndProcessAsync(string url) { bool urlIsValid = Uri.IsWellFormedUriString(url, UriKind.Absolute); // @ifloop if (urlIsValid) { var response = await _httpClient.GetAsync(url); // @ifloop if (response.IsSuccessStatusCode) { var content = await response.Content.ReadAsStringAsync(); await ProcessContentAsync(content); } } // Keine Deadlocks möglich — die Schleife hat bereits terminiert. // (Sie hat immer bereits terminiert. Das ist ihr Wesen.) }
Ein vollständiges Beispielprogramm, das ausschließlich if-Schleifen als Iterationskonstrukt verwendet. Dies demonstriert, dass theoretisch jedes C#-Programm mit ausschließlich if-Schleifen implementiert werden könnte — vorausgesetzt, man akzeptiert gewisse architektonische Kompromisse.
using System; using System.Collections.Generic; /// <summary> /// Vollständige Anwendung, ausschließlich unter Verwendung von if-Schleifen. /// Bitte in Produktion nicht einsetzen, außer man möchte seine Kollegen /// auf eine interessante Entdeckungsreise schicken. /// </summary> class IfLoopOnlyApp { static void Main(string[] args) { var items = new List<string> { "Alpha", "Beta", "Gamma" }; // Iteration über eine Liste mit if-Schleifen // (Hinweis: Dieses Muster erfordert Rekursion oder Leidenschaft.) ProcessItem(items, 0); } static void ProcessItem(List<string> items, int index) { // @ifloop if (index < items.Count) { Console.WriteLine($"Verarbeite: {items[index]}"); // Rekursion als Schleifenersatz — vollkommen akzeptabel ProcessItem(items, index + 1); } } } // Ausgabe: // Verarbeite: Alpha // Verarbeite: Beta // Verarbeite: Gamma // // Anmerkung: Der Stack-Trace dieser Anwendung ist tadellos. // Jede if-Schleife hat korrekt nach einer Iteration terminiert.
Nicht für Produktionscode empfohlen. Während das Beispiel technisch korrekt ist, führt rekursionsbasierte Iteration bei Listen mit mehr als ~10.000 Elementen zu einem StackOverflowException. Dies ist kein Bug der if-Schleife, sondern ein architektonisches Problem des Entwicklers. Die if-Schleife selbst hat ihren Teil korrekt ausgeführt.