Wie funktionieren Iteratoren und das yield-Schlüsselwort?

Question

Accepted Answer

**Iteratoren** ermöglichen es dir, eine Sequenz von Werten faul zu erzeugen, einen nach dem anderen, mit dem **`yield`**-Schlüsselwort — ohne die gesamte Kollektion im Speicher zu erstellen. Eine Methode mit `yield return` wird zu einem Iterator, der Werte auf Anforderung generiert, ideal für große oder unendliche Sequenzen und benutzerdefinierte Iteration. ## yield return — faule Sequenzgenerierung ```csharp // a method with `yield return` is an ITERATOR — produces values one at a time public IEnumerable GetNumbers(int n) { for (int i = 0; i < n; i++) { yield return i; // produce a value, PAUSE here, resume on the next request } } foreach (var num in GetNumbers(1000000)) // generates lazily — minimal memory { Console.WriteLine(num); if (num > 5) break; // only generated 7 values — the rest were never computed } ``` `yield return` produziert einen Wert und **pausiert** die Methode, setzt sie beim nächsten Durchlauf fort, wo sie stehen geblieben ist (erhält den Zustand). Werte werden **auf Anforderung** generiert — nichts wird berechnet, bis es angefordert wird, und ein `break` stoppt die Generierung frühzeitig. ## Der Speichervorteil (faul vs. eifrig) ```csharp // ❌ eager — builds the WHOLE list in memory first public List GetAll(int n) { var list = new List(); for (int i = 0; i < n; i++) list.Add(i); // all n values in memory return list; } // ✅ iterator — generates lazily, constant memory regardless of n public IEnumerable GetAll(int n) { for (int i = 0; i < n; i++) yield return i; } ``` ## Unendliche Sequenzen (unmöglich mit einer Liste) ```csharp public IEnumerable Fibonacci() { int a = 0, b = 1; while (true) // infinite — but lazy, so it's fine { yield return a; (a, b) = (b, a + b); } } var first10 = Fibonacci().Take(10); // take only what you need ``` ## yield und LINQ ```text LINQ's deferred execution is built on iterators — Where/Select use yield internally to process elements lazily, one at a time, as the result is enumerated. ``` ## Warum es wichtig ist Iteratoren und das `yield`-Schlüsselwort sind wichtige C#-Funktionen für **speichereffiziente, faule Sequenzgenerierung**, und das Verständnis dafür ist wertvoll für die Verarbeitung großer Datenmengen und zum Verständnis, wie LINQ funktioniert. Der Kernvorteil ist die Erzeugung von Sequenzen **faul, einen Wert nach dem anderen, auf Anforderung** — anstatt eine ganze Kollektion im Speicher zu erstellen — was essentiell ist für große Datenmengen (bei denen die Materialisierung alles den Speicher erschöpfen würde), Streaming-/Verarbeitungsszenarien und sogar **unendliche Sequenzen** (wie das Generieren von Fibonacci-Zahlen, unmöglich mit einer Liste, aber trivial mit einem faulen Iterator, wobei man nur das nimmt, was man braucht). Der `yield return`-Mechanismus (Erzeugung eines Wertes, Pausierung, Wiederaufnahme mit behaltenem Zustand) macht das Schreiben solcher fauler Generatoren sauber und natürlich. Das Verständnis von Iteratoren beleuchtet auch, wie **aufgeschobene Ausführung von LINQ funktioniert** — LINQ-Operatoren verwenden Iteratoren intern, um Elemente faul zu verarbeiten, wenn das Ergebnis aufgezählt wird, was LINQs faulesVerhalten erklärt. Das Wissen über Iteratoren (faule Generierung mit `yield`, die Speichervorteil über eifrige Kollektion-Erstellung, unendliche Sequenzen und die Verbindung zur aufgeschobenen Ausführung von LINQ) ist wertvoll für das Schreiben von speichereffizientem Datenverarbeitungscode und zum Verständnis von C#s Modell der aufgeschobenen Auswertung — macht sie zu nützlichem, praktisch relevantem Wissen für effizientes C# und ein Thema, das Verständnis der aufgeschobenen Ausführungsfähigkeiten der Sprache widerspiegelt. Während nicht in jedem Szenario benötigt, sind Iteratoren wichtig bei der Verarbeitung großer Datenmengen effizient oder beim Erstellen benutzerdefinierter fauler Sequenzen, und das Verständnis dafür vertieft dein Verständnis von LINQ und fauler Auswertung — macht sie zu nützlichem, praktisch relevantem Wissen für effizientes C# und ein Thema, das Verständnis der aufgeschobenen Ausführungsfähigkeiten der Sprache widerspiegelt.