Iterators மற்றும் yield keyword எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**Iterators** என்பது `yield` keyword ஐ பயன்படுத்தி, முழு collection ஐ메모리இல் உருவாக்காமல், ஒரு நேரத்தில் ஒரு மதிப்பை게으ியமாக (lazily) உற்பத்தி செய்ய உதவுகிறது. `yield return` ஐ பயன்படுத்தும் method ஒரு iterator ஆக மாறி, தேவைக்கேற்ப மதிப்புகளை உற்பத்தி செய்கிறது — பெரிய அல்லது முடிவில்லாத sequences மற்றும் custom iteration க்கு இலட்சியமாக உள்ளது. ## yield return —게으ிய sequence உற்பத்தி ```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` ஒரு மதிப்பை உற்பத்தி செய்து method ஐ **நிறுத்துகிறது**, அடுத்த iteration இல் அது நின்ற இடத்திலிருந்து மீண்டும் தொடங்குகிறது (state பாதுகாக்கப்படுகிறது). மதிப்புகள் **தேவைக்கேற்ப** உற்பத்தி செய்யப்படுகிறது —요청될வரை எதுவும் கணக்கிடப்படவில்லை, மற்றும் ஒரு `break` early ஆக உற்பத்தியை நிறுத்துகிறது. ## Memory பலன் (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; } ``` ## முடிவில்லாத 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 என்பது C# இன் **memory-efficient,게으ிய sequence உற்பத்திக்கான** முக்கியமான features ஆகும், மற்றும் இவற்றைப் புரிந்துகொள்வது பெரிய datasets ஐ செயல்படுத்துவதற்கும் LINQ எவ்வாறு செயல்படுகிறது என்பதை புரிந்துகொள்வதற்கும் மதிப்புமிக்கது. குறிப்பிடப்பட்ட நன்மை என்பது sequences ஐ **게ously, ஒரு நேரத்தில் ஒரு மதிப்பை, தேவைக்கேற்ப** உற்பத்தி செய்வது — முழு collection ஐ memory இல் உருவாக்குவதற்குப் பதிலாக — இது பெரிய datasets (எல்லாவற்றையும் materialized செய்வது memory ஐ சரியாக்கும்), streaming/processing scenarios, மற்றும் **முடிவில்லாத sequences** (Fibonacci எண்களை உருவாக்குவது போன்றவை, list உடன் சாத்தியமில்லை ஆனால் game lazy iterator உடன் trivial, தேவையான வற்றை மட்டும் எடுத்துக்கொள்ளுகிறது) க்கு அপরிहार்யம்। `yield return` mechanism (ஒரு மதிப்பை உற்பத்தி செய்தல், நிறுத்துதல், பாதுகாக்கப்பட்ட state உடன் மீண்டும் தொடங்குதல்) அத்தகைய game generators ஐ깔끔்and naturally எழுத செய்கிறது. Iterators ஐ புரிந்துகொள்வது **LINQ இன் deferred execution எவ்வாறு செயல்படுகிறது** என்பதையும் illuminates செய்கிறது — LINQ operators internally iterators ஐ பயன்படுத்தி elements ஐ게ously செயல்படுத்துகிறது result enumerated செய்யப்படும்போது, இது LINQ இன் lazy behavior ஐ விளக்குகிறது. Iterators ஐ தெரிந்துகொள்வது (game generation with `yield`, memory benefits over eager collection-building, முடிவில்லாத sequences, மற்றும் LINQ இன் deferred execution உடன் கனெக்சன்) memory-efficient data-processing code எழுத பயனுள்ளவை, மற்றும் C# இன் game evaluation model ஐ புரிந்துகொள்வதற்கு மதிப்பு உள்ளவை. ஒவ்வொரு scenario க்கும் தேவையில்லை என்றாலும், iterators பெரிய அளவு data கள் efficiently செயல்படுத்துவதற்கும் அல்லது custom lazy sequences உருவாக்குவதற்கும் முக்கியமாக உள்ளது, மற்றும் அவற்றைப் புரிந்துகொள்வது LINQ மற்றும் lazy evaluation ஒன்றாக deepen செய்கிறது — அவற்றை useful, practically-relevant knowledge efficient C# க்குமாக வளர்த்து, language இன் deferred-execution capabilities ஐ புரிந்துகொள்ளும் topic ஆக மாற்றுகிறது.