Bagaimana cara kerja iterators dan kata kunci yield?

Question

IT Interview Practice · Accepted Answer

**Iterators** memungkinkan Anda menghasilkan urutan nilai secara lazy (malas), satu per satu, menggunakan kata kunci **`yield`** — tanpa membangun seluruh koleksi di memori. Sebuah metode yang menggunakan `yield return` menjadi iterator yang menghasilkan nilai sesuai permintaan, ideal untuk urutan yang besar atau tak terbatas dan iterasi kustom. ## yield return — lazy sequence generation ```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` menghasilkan nilai dan **menjeda** metode, melanjutkan dari mana ia berhenti pada iterasi berikutnya (melestarikan state). Nilai dihasilkan **sesuai permintaan** — tidak ada yang dihitung sampai diminta, dan `break` menghentikan generasi lebih awal. ## The memory benefit (lazy vs eager) ```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; } ``` ## Infinite sequences (impossible with a list) ```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 and 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. ``` ## Mengapa ini penting Iterators dan kata kunci `yield` adalah fitur C# yang penting untuk **lazy sequence generation yang efisien memori**, dan memahaminya bernilai untuk memproses dataset besar dan untuk memahami cara kerja LINQ. Keuntungan inti adalah menghasilkan urutan **secara lazy, satu nilai per satu, sesuai permintaan** — daripada membangun seluruh koleksi di memori — yang penting untuk dataset besar (di mana materialize semuanya akan menghabiskan memori), skenario streaming/pemrosesan, dan bahkan **infinite sequences** (seperti menghasilkan bilangan Fibonacci, tidak mungkin dengan list tetapi trivial dengan lazy iterator, hanya mengambil apa yang Anda butuhkan). Mekanisme `yield return` (menghasilkan nilai, menjeda, melanjutkan dengan state terjaga) membuat penulisan lazy generators semacam itu bersih dan alami. Memahami iterators juga menjelaskan cara kerja **deferred execution LINQ** — operator LINQ menggunakan iterators secara internal untuk memproses elemen secara lazy saat hasil dieumerasi, yang menjelaskan perilaku lazy LINQ. Mengetahui iterators (lazy generation dengan `yield`, keuntungan memori dibanding eager collection-building, infinite sequences, dan koneksi ke deferred execution LINQ) bernilai untuk menulis kode data-processing yang efisien memori dan untuk memahami model lazy evaluation C#. Meskipun tidak diperlukan untuk setiap skenario, iterators penting saat memproses jumlah data besar secara efisien atau membangun custom lazy sequences, dan memahaminya memperdalam pemahaman Anda tentang LINQ dan lazy evaluation — menjadikannya pengetahuan praktis dan berguna untuk C# yang efisien dan topik yang mencerminkan pemahaman tentang kemampuan deferred-execution bahasa.

yield return — lazy sequence generation

The memory benefit (lazy vs eager)

Infinite sequences (impossible with a list)

yield and LINQ

Mengapa ini penting

Pertanyaan terkait