Iteratori vam omogućavaju da lijenčivo generirate niz vrednosti, jednu po jednu, koristeći ključnu reč yield — bez učitavanja cele kolekcije u memoriju. Metoda koja koristi yield return postaje iterator koji generiše vrednosti po potrebi, idealan za velike ili beskonačne nizove i prilagođenu iteraciju.
{
( i = ; i < n; i++)
{
i;
}
}
(
{
Console.WriteLine(num);
(num > ) ;
}
yield return proizvodi vrednost i pauzira metodu, nastavljajući gde je stala pri sledećoj iteraciji (čuvajući stanje). Vrednosti se generišu po potrebi — ništa se ne računa dok nije traženo, a break zaustavlja generaciju ranije.
// ❌ 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.
Iteratori i ključna reč yield su važne C# karakteristike za memorijski efikasnu, ljenku generaciju niza, a razumevanje njih je korisno za obradu velikih skupova podataka i za shvatanje kako LINQ funkcionira.
Osnovni benefit je proizvodnja nizova lijenčivo, jedne vrednosti po jednoj, po potrebi — umesto gradnje cele kolekcije u memoriju — što je neophodno za velike skupove podataka (gde bi materijalizovanje svega iscrpelo memoriju), scenarije strujnog/obradnog toka i čak beskonačne nizove (poput generisanja Fibonačijevih brojeva, nemoguće sa listom ali trivijalno sa lijenim iteratorom, uzimajući samo ono što vam treba).
Mehanizam yield return (proizvodnja vrednosti, pauziranje, nastavak sa čuvanim stanjem) čini pisanje takvih lijenih generatora čistim i prirodnim.
Razumevanje iteratora takođe osvetljava kako odložena izvršavanja LINQ-a funkcionira — operatori LINQ-a interno koriste iteratore da obrađuju elemente lijenčivo kako se rezultat enumerira, što objašnjava ljenko ponašanje LINQ-a.
Znanje o iteratorima (lijena generacija sa yield, prednosti memorije naspram pohlepne gradnje kolekcije, beskonačni nizovi i veza sa odloženom izvršavanjem LINQ-a) je korisno za pisanje memorijski efikasnog koda obrade podataka i za razumevanje C# modela lijene evaluacije — čineći ih korisnim, praktično relevantnim znanjem za efikasan C# i temom koja odražava razumevanje mogućnosti odložene izvršavanja jezika.
Mada nije potrebno za svaki scenario, iteratori su važni pri obradi velikih količina podataka efikasno ili pri gradnji prilagođenih lijenih nizova, i razumevanje njih produbljuje vašu percepciju LINQ-a i lijenke evaluacije — čineći ih korisnim znanjem za efikasan C#.