Iteratorer lar deg produsere en sekvens av verdier lat, én av gangen, ved hjelp av yield-nøkkelordet — uten å bygge hele samlingen i minnet. En metode som bruker yield return blir en iterator som genererer verdier på forespørsel, ideell for store eller uendelige sekvenser og egendefinert iterasjon.
{
( i = ; i < n; i++)
{
i;
}
}
(
{
Console.WriteLine(num);
(num > ) ;
}
yield return produserer en verdi og pauser metoden, og gjenopptar der den stoppet ved neste iterasjon (bevarer tilstand). Verdier genereres på forespørsel — ingenting beregnes før det blir etterspurt, og en break stopper genereringen tidlig.
// ❌ 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.
Iteratorer og yield-nøkkelordet er viktige C#-funksjoner for minneeffektiv, lat sekvensgenering, og å forstå dem er verdifullt for behandling av store datasett og for å forstå hvordan LINQ fungerer.
Hovedfordelen er å produsere sekvenser lat, én verdi av gangen, på forespørsel — i stedet for å bygge en hel samling i minnet — som er essensielt for store datasett (hvor materialisering av alt ville oppbruke minne), streaming-/behandlingsscenarier, og til og med uendelige sekvenser (som å generere Fibonacci-tall, umulig med en liste men trivielt med en lat iterator, tar kun det du trenger).
yield return-mekanismen (produserer en verdi, pauser, gjenopptar med bevart tilstand) gjør det rent og naturlig å skrive slike late generatorer.
Å forstå iteratorer belyser også hvordan LINQs utsatt kjøring fungerer — LINQ-operatører bruker iteratorer internt for å behandle elementer lat ettersom resultatet oppregnes, noe som forklarer LINQs late atferd.
Å kjenne iteratorer (lat generering med yield, minnefordelene over ivrig samlingsbygging, uendelige sekvenser, og forbindelsen til LINQs utsatte kjøring) er verdifullt for å skrive minneeffektiv datakode og for å forstå C#s late evalueringsmodell.
Eller ikke nødvendig for alle scenarier, iteratorer er viktige når du behandler store mengder data effektivt eller bygger egendefinerte late sekvenser, og å forstå dem gir dypere forståelse av LINQ og lat evaluering — noe som gjør dem praktisk relevant kunnskap for effektiv C# og et emne som reflekterer forståelse av språkets utsatte kjøringsevner.