Iterators let you produce a sequence of values lazily, one at a time, using the yield keyword — without building the whole collection in memory. A method using yield return becomes an iterator that generates values on demand, ideal for large or infinite sequences and custom iteration.
{
( i = ; i < n; i++)
{
i;
}
}
(
{
Console.WriteLine(num);
(num > ) ;
}
yield return produces a value and pauses the method, resuming where it left off on the next iteration (preserving state). Values are generated on demand — nothing is computed until requested, and a break stops generation early.
// ❌ 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 and the yield keyword are important C# features for memory-efficient, lazy sequence generation, and understanding them is valuable for processing large datasets and for grasping how LINQ works.
The core benefit is producing sequences lazily, one value at a time, on demand — rather than building an entire collection in memory — which is essential for large datasets (where materializing everything would exhaust memory), streaming/processing scenarios, and even infinite sequences (like generating Fibonacci numbers, impossible with a list but trivial with a lazy iterator, taking only what you need).
The yield return mechanism (producing a value, pausing, resuming with preserved state) makes writing such lazy generators clean and natural.
Understanding iterators also illuminates how LINQ's deferred execution works — LINQ operators use iterators internally to process elements lazily as the result is enumerated, which explains LINQ's lazy behavior.
Knowing iterators (lazy generation with yield, the memory benefits over eager collection-building, infinite sequences, and the connection to LINQ's deferred execution) is valuable for writing memory-efficient data-processing code and for understanding C#'s lazy evaluation model.
While not needed for every scenario, iterators are important when processing large amounts of data efficiently or building custom lazy sequences, and understanding them deepens your grasp of LINQ and lazy evaluation — making them useful, practically-relevant knowledge for efficient C# and a topic that reflects understanding of the language's deferred-execution capabilities.