ਇਟਰੇਟਰ ਅਤੇ yield ਕੀਵਰਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

**Iterators** ਤੁਹਾਨੂੰ `yield` ਕੀਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਵਾਰ ਇੱਕ ਮੁੱਲ ਦਾ ਕ੍ਰਮ ਸੁਸਤੀ ਨਾਲ ਤਿਆਰ ਕਰਨ ਦਿੰਦੇ ਹਨ — ਸਮੁੱਚੇ ਸੰਗ੍ਰਹਿ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਬਣਾਏ ਬਿਨਾਂ। `yield return` ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲਾ ਇੱਕ ਤਰੀਕਾ ਇੱਕ iterator ਬਣ ਜਾਂਦਾ ਹੈ ਜੋ ਮੰਗ 'ਤੇ ਮੁੱਲ ਪੈਦਾ ਕਰਦਾ ਹੈ, ਬੜੇ ਜਾਂ ਅਨੰਤ ਤਰਤੀਬਾਂ ਅਤੇ ਕਸਟਮ ਦੁਹਰਾਉਂਦੀ ਲਈ ਆਦਰਸ਼। ## 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` ਇੱਕ ਮੁੱਲ ਪੈਦਾ ਕਰਦਾ ਹੈ ਅਤੇ **ਰੁਕਦਾ** ਹੈ, ਵਿਧੀ ਨੂੰ ਅਗਲੇ ਦੁਹਰਾਉ 'ਤੇ ਮੁੜ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ (ਸਥਿਤੀ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਦੇ ਹੋਏ)। ਮੁੱਲ **ਮੰਗ 'ਤੇ** ਤਿਆਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ — ਜ਼ਾਹਰ ਤੱਕ ਕੁਝ ਵੀ ਗਣਨਾ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ, ਅਤੇ ਇੱਕ `break` ਜਨਰੇਸ਼ਨ ਨੂੰ ਜਲਦੀ ਰੋਕ ਦਿੰਦਾ ਹੈ। ## ਮੈਮੋਰੀ ਦਾ ਲਾਭ (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; } ``` ## ਅਨੰਤ ਤਰਤੀਬਾਂ (ਇੱਕ ਸੂਚੀ ਨਾਲ ਅਸੰਭਵ) ```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` ਕੀਵਰਡ **ਮੈਮੋਰੀ-ਕੁਸ਼ਲ, lazy sequence generation** ਲਈ ਮਹੱਤਵਪੂਰਨ C# ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਵੱਡੇ ਡੇਟਾਸੈਟਾਂ ਨੂੰ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਅਤੇ LINQ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਸਮਝਣ ਲਈ ਮੁੱਲਵਾਨ ਹੈ। ਮੂਲ ਲਾਭ **lazy ਤੌਰ 'ਤੇ, ਇੱਕ ਵਾਰ ਇੱਕ ਮੁੱਲ, ਮੰਗ 'ਤੇ** ਕ੍ਰਮ ਪੈਦਾ ਕਰਨਾ ਹੈ — ਸਾਰੇ ਸੰਗ੍ਰਹਿ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਬਣਾਉਣ ਦੀ ਬਜਾਏ — ਜੋ ਵੱਡੇ ਡੇਟਾਸੈਟਾਂ (ਜਿੱਥੇ ਸਭ ਕੁਝ ਸਮੱਗ੍ਰੀ ਮੈਮੋਰੀ ਖਤਮ ਕਰ ਦੇਵੇ), ਸਟ੍ਰੀਮਿੰਗ/ਪ੍ਰੋਸੈਸਿੰਗ ਸਥਿਤੀਆਂ, ਅਤੇ ਇਹਨਾਂ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕਿ **ਅਨੰਤ ਕ੍ਰਮ** (ਜਿਵੇਂ Fibonacci ਨੰਬਰ ਤਿਆਰ ਕਰਨਾ, ਇੱਕ ਸੂਚੀ ਨਾਲ ਅਸੰਭਵ ਪਰ ਇੱਕ lazy iterator ਨਾਲ ਮਾਮੂਲੀ, ਸਿਰਫ ਚਾਹੁਂਦੀ ਚੀਜ਼ ਲਓ)। `yield return` ਮਕੈਨਿਜ਼ਮ (ਇੱਕ ਮੁੱਲ ਪੈਦਾ ਕਰਨਾ, ਰੁਕਨਾ, ਸੁਰੱਖਿਅਤ ਸਥਿਤੀ ਦੇ ਨਾਲ ਮੁੜ ਸ਼ੁਰੂ ਕਰਨਾ) ਅਜਿਹੇ lazy ਜਨਰੇਟਰ ਲਿਖਣਾ ਸਾਫ਼ ਅਤੇ ਕੁਦਰਤੀ ਬਣਾਉਂਦਾ ਹੈ। Iterators ਨੂੰ ਸਮਝਣਾ **LINQ ਦੀ deferred execution ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ** ਨੂੰ ਵੀ ਸਪਸ਼ਟ ਕਰਦਾ ਹੈ — LINQ ਓਪਰੇਟਰ lazy ਤੌਰ 'ਤੇ ਤੱਤਾਂ ਨੂੰ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ iterators ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਜਿਵੇਂ ਕਿ ਨਤੀਜਾ ਖੋਜਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ LINQ ਦੇ lazy ਵਿਵਹਾਰ ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ। Iterators ਨੂੰ ਜਾਣਨਾ (lazy generation `yield` ਨਾਲ, eager collection-building ਤੋਂ ਮੈਮੋਰੀ ਦੇ ਲਾਭ, ਅਨੰਤ ਕ੍ਰਮ, ਅਤੇ LINQ ਦੀ deferred execution ਨਾਲ ਸਬੰਧ) ਮੈਮੋਰੀ-ਕੁਸ਼ਲ ਡੇਟਾ-ਪ੍ਰੋਸੈਸਿੰਗ ਕੋਡ ਲਿਖਣ ਲਈ ਮੁੱਲਵਾਨ ਹੈ ਅਤੇ C# ਦੀ lazy evaluation ਮਾਡਲ ਨੂੰ ਸਮਝਣ ਲਈ ਹੈ। ਜਦਕਿ ਹਰੇਕ ਸਥਿਤੀ ਲਈ ਜ਼ਰੂਰੀ ਨਹੀਂ, iterators ਬਹੁਤ ਵਾਲੀ ਡੇਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਜਾਂ ਕਸਟਮ lazy ਕ੍ਰਮ ਬਣਾਉਂਦੇ ਸਮੇਂ ਮਹੱਤਵਪੂਰਨ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ LINQ ਅਤੇ lazy evaluation ਦਾ ਤੁਹਾਡਾ ਗ੍ਰਹਿ ਕਰਦਾ ਹੈ — ਉਹਨਾਂ ਨੂੰ ਕੁਸ਼ਲ C# ਲਈ ਲਾਭਦਾਇਕ, ਵਿਹਾਰਕ-ਮਾਨਯੋਗ ਜਾਣਕਾਰੀ ਬਣਾ ਰਿਹਾ ਹੈ ਅਤੇ ਇੱਕ ਵਿਸ਼ਾ ਜੋ ਭਾਸ਼ਾ ਦੀ deferred-execution ਸਮਰੱਥਾ ਨੂੰ ਸਮਝ ਦਿਖਾਉਂਦਾ ਹੈ।