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.
// a method with `yield return` is an ITERATOR — produces values one at a time
public IEnumerable<int> 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.
// ❌ eager — builds the WHOLE list in memory first
public List<int> GetAll(int n)
{
var list = new List<int>();
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<int> GetAll(int n)
{
for (int i = 0; i < n; i++) yield return i;
}
public IEnumerable<int> 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
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 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.
Leabharlann de cheisteanna agallaimh TF le freagraí mionsonraithe — ó Shóisearach go Sinsearach.
Síntiús