Jak działają iteratory i słowo kluczowe yield?

Question

Accepted Answer

**Iteratory** pozwalają na generowanie sekwencji wartości leniwie, jedną na raz, używając słowa kluczowego **`yield`** — bez budowania całej kolekcji w pamięci. Metoda używająca `yield return` staje się iteratorem, który generuje wartości na żądanie, idealnie nadając się do dużych lub nieskończonych sekwencji oraz iteracji niestandardowych. ## yield return — leniwe generowanie sekwencji ```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` daje wartość i **wstrzymuje** metodę, wznawianą w punkcie przerwania w następnej iteracji (zachowując stan). Wartości są generowane **na żądanie** — nic nie jest obliczane, dopóki nie będzie potrzebne, a `break` zatrzymuje generowanie wcześnie. ## Korzyść pamięciowa (leniwie vs gorliwie) ```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; } ``` ## Sekwencje nieskończone (niemożliwe za pomocą listy) ```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 i 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. ``` ## Dlaczego to ważne Iteratory i słowo kluczowe `yield` są ważnymi funkcjami C# do **efektywnego pamięciowo, leniwego generowania sekwencji**, a ich zrozumienie jest wartościowe dla przetwarzania dużych zbiorów danych oraz do pojmowania sposobu działania LINQ. Główną korzyścią jest generowanie sekwencji **leniwie, jedną wartość na raz, na żądanie** — zamiast budowania całej kolekcji w pamięci — co jest niezbędne dla dużych zbiorów danych (gdzie zmaterializowanie wszystkiego wyczerpałoby pamięć), scenariuszy transmisji/przetwarzania danych, a nawet **nieskończonych sekwencji** (jak generowanie liczb Fibonacciego, niemożliwe na liście, ale trywialne z leniwym iteratorem, biorąc tylko to, co potrzebujesz). Mechanizm `yield return` (danie wartości, wstrzymanie, wznowienie z zachowanym stanem) czyni pisanie takich leniwych generatorów czystym i naturalnym. Zrozumienie iteratorów również wyjaśnia, jak **odroczone wykonanie LINQ** — operatory LINQ używają wewnętrznie iteratorów do przetwarzania elementów leniwie w miarę wyliczania wyniku, co tłumaczy leniwe zachowanie LINQ. Znajomość iteratorów (leniwe generowanie z `yield`, korzyści pamięciowe w stosunku do gorliwego budowania kolekcji, nieskończone sekwencje i połączenie z odroconym wykonaniem LINQ) jest wartościowa dla pisania wydajnego pamięciowo kodu przetwarzającego dane oraz dla zrozumienia modelu leniwej oceny C#, czyniąc je użyteczną, praktycznie istotną wiedzą dla efektywnego C# i tematem, który odzwierciedla zrozumienie możliwości odroczonego wykonania w języku.