iterators और yield keyword कैसे काम करते हैं?

Question

Accepted Answer

**Iterators** आपको **`yield`** keyword का उपयोग करके values का एक sequence lazily, एक समय में एक उत्पन्न करने देते हैं — पूरे collection को memory में बनाए बिना। `yield return` का उपयोग करने वाला एक method एक iterator बन जाता है जो मांग पर values उत्पन्न करता है, बड़े या infinite sequences और custom iteration के लिए आदर्श। ## 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` एक value उत्पन्न करता है और method को **pause** करता है, अगली iteration पर जहां छोड़ा था वहां से resume करते हुए (state को संरक्षित करते हुए)। Values **मांग पर** उत्पन्न होती हैं — कुछ भी तब तक compute नहीं होता जब तक अनुरोध न किया जाए, और एक `break` generation को जल्दी रोक देता है। ## memory लाभ (lazy बनाम 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 (एक 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 और 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. ``` ## यह क्यों महत्वपूर्ण है iterators और `yield` keyword **memory-efficient, lazy sequence generation** के लिए महत्वपूर्ण C# विशेषताएं हैं, और इन्हें समझना बड़े datasets को process करने के लिए और यह समझने के लिए मूल्यवान है कि LINQ कैसे काम करता है। मुख्य लाभ sequences को **lazily, एक समय में एक value, मांग पर** उत्पन्न करना है — पूरे collection को memory में बनाने के बजाय — जो बड़े datasets (जहां सब कुछ materialize करना memory को समाप्त कर देगा), streaming/processing परिदृश्यों, और यहां तक कि **infinite sequences** (जैसे Fibonacci numbers उत्पन्न करना, एक list के साथ असंभव लेकिन एक lazy iterator के साथ trivial, केवल जो आपको चाहिए वह लेना) के लिए आवश्यक है। `yield return` तंत्र (एक value उत्पन्न करना, pause करना, संरक्षित state के साथ resume करना) ऐसे lazy generators लिखना साफ और स्वाभाविक बनाता है। iterators को समझना यह भी स्पष्ट करता है कि **LINQ का deferred execution कैसे काम करता है** — LINQ operators elements को lazily process करने के लिए internally iterators का उपयोग करते हैं जैसे result enumerate होता है, जो LINQ के lazy व्यवहार को समझाता है। iterators को जानना (`yield` के साथ lazy generation, eager collection-building पर memory लाभ, infinite sequences, और LINQ के deferred execution से संबंध) memory-efficient data-processing कोड लिखने के लिए और C# के lazy evaluation मॉडल को समझने के लिए मूल्यवान है। हालांकि हर परिदृश्य के लिए आवश्यक नहीं, iterators महत्वपूर्ण हैं जब बड़ी मात्रा में data को कुशलता से process करना या custom lazy sequences बनाना, और इन्हें समझना LINQ और lazy evaluation की आपकी समझ को गहरा करता है — उन्हें कुशल C# के लिए उपयोगी, व्यावहारिक रूप से प्रासंगिक ज्ञान बनाते हुए और एक विषय जो भाषा की deferred-execution क्षमताओं की समझ दर्शाता है।