Conas a fheidhmíonn iterators agus an eochairfhocal yield?

Question

Accepted Answer

**Iterators** a ligeann duit seicheamh de luachanna a tháirgeadh go mall, a dhá cheann ar bharr a chéile, agus an **`yield`** eochairfhocal á úsáid — gan an bhailiúchán ar fad a thógáil i gcuimhne. Modh ag úsáid `yield return` a bhíonn ina iterator a ghealadh luachanna ar éileamh, go hiontach do sheicheamhanna móra nó gan críoch agus atriall saincheaptha. ## yield return — giniúint seicheamh mall ```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` a tháirgeann luach agus **soiceannaí** an modh, ag tosú arís ó bhí sé fágtha ar an chéad atriall eile (staid a chaomhnú). Luachanna a ghineadh **ar éileamh** — ní ní ar bith ríofa go dtí a iarrtar, agus `break` a chuireann deireadh leis an ghiniúint go luath. ## An sochar cuimhne (mall in aghaidh fonnmhar) ```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; } ``` ## Seicheamhanna gan críoch (dodhéanta le liosta) ```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 agus 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. ``` ## Cén fáth a bhfuil sé tábhachtach Iterators agus an **`yield`** eochairfhocal iad gné thábhachtach C# do **ghiniúint seicheamh mall agus éifeachtúil ar an bhealach cuimhne**, agus tá siad luachmhar a thuigint do dhátasetanna móra a phróiseáil agus do dhealrú ar conas LINQ ag obair. An sochar croílár ná seicheamhanna a tháirgeadh **go mall, luach amháin ar bharr a chéile, ar éileamh** — seachas bailiúchán ar fad a thógáil i gcuimhne — ar fhéadfadh a bheith riachtanach do dhátasetanna móra (nuair a scartha gach rud é cuimhne a dhíothú), sruthanna/próiseáil, agus fiú **seicheamhanna gan críoch** (cosúil le huimhreacha Fibonacci a ghiniúint, dodhéanta le liosta ach fánach le iterator mall, ag tógáil ach rud ba bhreá leat). An `yield return` meicníc (luach a tháirgeadh, soiceannaí, ag tosú arís le staid caomhnaithe) a dhéanann scríobh leithéid gineadóir mall geal agus nádúrtha. Iterators a thuigint chomh maith soilsiú ar an dóigh ar fheidhmíonn **forghníomhú fionraithe LINQ** — úsáideann oibreoirí LINQ iterators taobh istigh le eilimintí a phróiseáil go mall agus an toradh á dhíreamh, a mhíníonn iompar mall LINQ. Iterators (giniúint mall le `yield`, na buntáistí cuimhne thar thógáil bailiúcháin fonnmhar, seicheamhanna gan críoch, agus an ceangal do forghníomhú fionraithe LINQ) a bheidh luachmhar do chód próiseála sonraí éifeachtúil a scríobh agus do thuigint ar mhúnla fionraithe LINQ an tsloinne — ag déanamh iad úsáideach, eolas praiticiúil ábhartha do C# éifeachtúil agus topaice a léiríonn tuiscint ar dheis fionraithe-ghníomhaithe an teanga. Cé go nach bhfuil gá a gach cás, iterators tábhachtach nuair a bhíonn méadaithe bhreá do sonraí a phróiseáil go héifeachtúil nó seicheamhanna mall saincheaptha a thógáil, agus tuiscint iad a dhoimhniú do do dhealrú ar LINQ agus fionraithe — ag déanamh iad úsáideach, eolas praiticiúil i C# éifeachtúil agus topaice a léiríonn tuiscint ar dheis fionraithe-ghníomhaithe an teanga.