Iterátory umožňují produkovat sekvenci hodnot lenivě, jednu po druhé, pomocí klíčového slova yield — bez nutnosti budovat celou kolekci v paměti. Metoda používající yield return se stává iterátorem, který generuje hodnoty na požadavek, což je ideální pro velké nebo nekonečné sekvence a vlastní iteraci.
{
( i = ; i < n; i++)
{
i;
}
}
(
{
Console.WriteLine(num);
(num > ) ;
}
yield return produkuje hodnotu a pozastaví metodu, pokračuje tam, kde skončila, při další iteraci (zachovává stav). Hodnoty jsou generovány na požadavek — nic se nepočítá, dokud není požadováno, a break zastaví generování brzy.
// ❌ 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.
Iterátory a klíčové slovo yield jsou důležitými funkcemi C# pro efektivní z hlediska paměti, lenivou generaci sekvencí, a jejich pochopení je cenné pro zpracování velkých datových sad a pro pochopení fungování LINQ.
Hlavní výhodou je produkování sekvencí lenivě, jednu hodnotu po druhé, na požadavek — místo budování celé kolekce v paměti — což je nezbytné pro velké datové sady (kde materializace všeho by vyčerpala paměť), scénáře streamování/zpracování a dokonce i nekonečné sekvence (jako generování Fibonacciho čísel, nemožné se seznamem, ale triviální s lenivým iterátorem, kdy vezmete pouze to, co potřebujete).
Mechanismus yield return (produkování hodnoty, pozastavení, pokračování se zachovaným stavem) činí psaní takových lenivých generátorů čistým a přirozeným.
Pochopení iterátorů také objasňuje, jak funguje odložené vykonávání LINQ — operátory LINQ používají iterátory interně pro lenivé zpracování prvků, jak se výsledek vyčíslovává, což vysvětluje lenivé chování LINQ.
Znalost iterátorů (lenivá generace s yield, výhody paměti oproti dychtivému budování kolekcí, nekonečné sekvence a spojení s odloženým vykonáváním LINQ) je cenná pro psaní paměťově efektivního kódu pro zpracování dat a pro pochopení modelu lenivého vyhodnocování C#. Zatímco není nutné pro každý scénář, iterátory jsou důležité při zpracování velkého množství dat efektivně nebo při budování vlastních lenivých sekvencí, a jejich pochopení prohlubujeváš chápání LINQ a lenivého vyhodnocování — činícím je užitečné, prakticky relevantní vědomosti pro efektivní C# a téma, které odráží pochopení možností odloženého vykonávání jazyka.