Iterators suna ba ka damar samar da jerin ƙyameti a hankali, ɗaya sannan ɗaya, ta amfani da yield keyword — ba tare da gina duk taron a memory ba. Hanya da ta amfani da yield return ta zama mai samarwa da jeri wanda ya samar da ƙyameti a buɗe, kyau sosai don girma ko marasa iyaka na jerin da kuma tsararren likita.
{
( i = ; i < n; i++)
{
i;
}
}
(
{
Console.WriteLine(num);
(num > ) ;
}
yield return yana samar da ƙymeti kuma yana tsayawa hanya, sake farawa inda ya tsaya a jere na gida (adana jiha). Ƙyameti ana samarwa a buɗe — ba wani abin da aka lissafi har sai an bukaci, kuma break yana dakatar da samarwa da wuri.
// ❌ 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 da yield keyword sune mahimman C# abubuwa don samar da jerin da ba ta mai memory a hankali, kuma fahimtar su yana da daraja don aiki da manyan bayani kuma don fahimtar yadda LINQ ke aiki.
Samun amfani babbar shine samar da jerin a hankali, ɗaya ƙymeti a lokaci, a buɗe — maimakon gina duk taron a memory — wanda ya zama dole-doler don manyan bayani (inda gina duk abu ya ɗauke memory), magudanar ruwa/processing abubuwa, kuma har ma jerin marasa iyaka (kamar samar da lambobi na Fibonacci, ba zai yiwu ba tare da jeri ba amma saya da hankali tare da mai samarwa na hankali, ɗaukar abin da kake bukaci kawai).
Hali na yield return (samar da ƙymeti, tsayawa, sake farawa tare da adana jiha) yana sa rubuta makiyaya masu hankali mai tsafi da natural.
Fahimtar iterators kuma yana wallafe yadda deferred execution na LINQ ke aiki — LINQ masu aiki suna amfani da iterators a ciki don aiki da abubuwa a hankali yayin da aka lissafa sakamakon, wanda ya bayyana hali na hankali na LINQ.
Sanin iterators (samar da hankali tare da yield, kumakala yin amfani akan hankali maida mai amfani da samuwa-taron, jerin marasa iyaka, da haɗi ga deferred execution na LINQ) yana da daraja don rubuta code na aiki na bayani na memory da kuma don fahimtar ɗan C# na lazy evaluation model.
Ko ba a buƙaci a duk lokaci ba, iterators sune mahimma lokacin aiki da manyan bayani a hankali ko gina tsararren jeri na hankali, kuma fahimtar su yana zaddawa fahimtar ku na LINQ da hankali — yana sa su da amfani, gida-amfani da ilimi ga C# da a batu da ke nuni da fahimtar kumakalan deferred-execution.