Iterators låter dig producera en sekvens av värden långsamt, ett i taget, med hjälp av nyckelordet yield — utan att bygga hela samlingen i minnet. En metod som använder yield return blir en iterator som genererar värden på begäran, perfekt för stora eller oändliga sekvenser och anpassad iteration.
{
( i = ; i < n; i++)
{
i;
}
}
(
{
Console.WriteLine(num);
(num > ) ;
}
yield return producerar ett värde och pausar metoden, återupptar där den slutade vid nästa iteration (bevarar tillståndet). Värden genereras på begäran — ingenting beräknas förrän det efterfrågas, och ett break stoppar genereringen tidigt.
// ❌ 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 och yield-nyckelordet är viktiga C#-funktioner för minneseffektiv, lat sekvensgeneration, och att förstå dem är värdefullt för att bearbeta stora datamängder och för att förstå hur LINQ fungerar.
Kärnfördelningen är att producera sekvenser långsamt, ett värde i taget, på begäran — snarare än att bygga en hel samling i minnet — vilket är väsentligt för stora datamängder (där materialisering av allt skulle slösa minne), streaming-/bearbetningsscenarier och till och med oändliga sekvenser (som att generera Fibonacci-nummer, omöjligt med en lista men trivialt med en lat iterator, ta bara det du behöver).
Mekanismen yield return (producera ett värde, pausa, återuppta med bevarat tillstånd) gör att skrivandet av sådana lata generatorer blir rent och naturligt.
Att förstå iterators belyser också hur LINQ:s uppskjutna körning fungerar — LINQ-operatorer använder iterators internt för att bearbeta element långsamt när resultatet räknas upp, vilket förklarar LINQ:s lata beteende.
Att känna till iterators (lat generering med yield, minnesfördelarna jämfört med brådskande samlingsbygge, oändliga sekvenser och kopplingen till LINQ:s uppskjutna körning) är värdefullt för att skriva minneseffektiv datakod och för att förstå C#:s lata utvärderingsmodell.
Even om det inte behövs för varje scenario, är iterators viktiga när du bearbetar stora mängder data effektivt eller bygger anpassade lata sekvenser, och att förstå dem fördjupar din förståelse för LINQ och lat utvärdering — vilket gör dem användbar, praktiskt relevant kunskap för effektiv C# och ett ämne som återspeglar förståelse för språkets uppskjutna körningsförmåga.