Iterators laten je een reeks waarden traag produceren, één tegelijk, met behulp van het yield-keyword — zonder de hele collectie in het geheugen op te slaan. Een methode die yield return gebruikt, wordt een iterator die waarden op aanvraag genereert, ideaal voor grote of oneindige reeksen en aangepaste iteratie.
{
( i = ; i < n; i++)
{
i;
}
}
(
{
Console.WriteLine(num);
(num > ) ;
}
yield return produceert een waarde en pauzeerd de methode, hervat waar deze was gebleven bij de volgende iteratie (behoud van staat). Waarden worden op aanvraag gegenereerd — niets wordt berekend totdat dit wordt aangevraagd, en een break stopt de generatie voortijdig.
// ❌ 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 en het yield-keyword zijn belangrijke C#-functies voor geheugenefficiënte, traag gegenereerde reeksen, en het begrijpen ervan is waardevol voor het verwerken van grote gegevenssets en voor het begrijpen hoe LINQ werkt.
Het kernvoordeel is het produceren van reeksen traag, één waarde tegelijk, op aanvraag — in plaats van een hele collectie in het geheugen op te bouwen — wat essentieel is voor grote gegevenssets (waarbij het materialiseren van alles het geheugen zou uitputten), streaming-/verwerkingsscenario's, en zelfs oneindige reeksen (zoals het genereren van Fibonacci-getallen, onmogelijk met een lijst, maar triviaal met een traag iterator, waarbij je alleen neemt wat je nodig hebt).
Het yield return-mechanisme (het produceren van een waarde, pauzeren, hervatten met behoud van staat) maakt het schrijven van dergelijke traag generatoren schoon en natuurlijk.
Het begrijpen van iterators werpt ook licht op hoe LINQ's uitgestelde uitvoering werkt — LINQ-operatoren gebruiken iterators intern om elementen traag te verwerken als het resultaat wordt geënumereerd, wat LINQ's traag gedrag verklaart.
Het kennen van iterators (traag generatie met yield, de geheugenvoordelen ten opzichte van voorgepland collectieaufbouw, oneindige reeksen, en de verbinding met LINQ's uitgestelde uitvoering) is waardevol voor het schrijven van geheugenefficiënte gegevensverwerkingscode en voor het begrijpen van C#'s traag evaluatiemodel.
Alhoewel niet nodig voor elk scenario, zijn iterators belangrijk bij het efficiënt verwerken van grote hoeveelheden gegevens of het bouwen van aangepaste traag reeksen, en het begrijpen ervan verdiept je begrip van LINQ en traag evaluatie — waardoor ze nuttige, praktisch relevante kennis voor efficiënte C# zijn en een onderwerp dat het begrip van de uitgestelde uitvoeringscapaciteiten van de taal weerspiegelt.