Iteratorii vă permit să produceți o secvență de valori leneș, una câte una, folosind cuvântul cheie yield — fără a construi întreaga colecție în memorie. O metodă care folosește yield return devine un iterator care generează valori la cerere, ideal pentru secvențe mari sau infinite și pentru iterație personalizată.
{
( i = ; i < n; i++)
{
i;
}
}
(
{
Console.WriteLine(num);
(num > ) ;
}
yield return produce o valoare și suspendă metoda, reluând din punctul în care s-a oprit la iterația următoare (păstrând starea). Valorile sunt generate la cerere — nimic nu se calculează până nu este solicitat, iar un break oprește generarea mai devreme.
// ❌ 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.
Iteratorii și cuvântul cheie yield sunt caracteristici importante ale C# pentru generarea de secvențe eficientă din punct de vedere al memoriei, leneșă, iar înțelegerea lor este valoroasă pentru procesarea unor seturi mari de date și pentru înțelegerea modului în care funcționează LINQ.
Beneficiul de bază este producerea secvențelor leneș, una câte una, la cerere — mai degrabă decât construirea unei întregi colecții în memorie — ceea ce este esențial pentru seturi mari de date (unde materializarea tuturor ar epuiza memoria), pentru scenarii de streaming/procesare și chiar pentru secvențe infinite (cum ar fi generarea numerelor Fibonacci, imposibilă cu o listă dar trivială cu un iterator leneș, luând doar ceea ce aveți nevoie).
Mecanismul yield return (producerea unei valori, suspendare, reluare cu stare păstrată) face ca scrierea unor generatori leneși să fie curată și naturală.
Înțelegerea iteratorilor iluminează, de asemenea, cum funcționează execuția amânată a LINQ-ului — operatorii LINQ folosesc iteratori intern pentru a procesa elementele leneș pe măsură ce rezultatul este enumerat, ceea ce explică comportamentul leneș al LINQ.
Cunoașterea iteratorilor (generarea leneșă cu yield, beneficiile de memorie față de construirea entuziastă de colecții, secvențe infinite și conexiunea la execuția amânată a LINQ) este valoroasă pentru scrierea unui cod de procesare a datelor eficient din punct de vedere al memoriei și pentru înțelegerea modelului de evaluare leneș al C#. Deși nu este necesară în fiecare scenariu, iteratorii sunt importanți atunci când procesați o cantitate mare de date eficient sau când construiți secvențe personalizate leneșe, iar înțelegerea lor aprofundează înțelegerea capacităților de execuție amânată ale limbajului — făcând din ei cunoștințe utile și practice pentru C# eficient și un subiect care reflectă înțelegerea modelului de evaluare amânată al limbajului.