Why do we need iterators in c#?

Question

Can somebody provide a real life example regarding use of iterators. I tried searching google but was not satisfied with the answers.

Answer 1

You've probably heard of arrays and containers - objects that store a list of other objects.

But in order for an object to represent a list, it doesn't actually have to "store" the list. All it has to do is provide you with methods or properties that allow you to obtain the items of the list.

In the .NET framework, the interface IEnumerable is all an object has to support to be considered a "list" in that sense.

To simplify it a little (leaving out some historical baggage):

public interface IEnumerable
{
    IEnumerator GetEnumerator();
}

So you can get an enumerator from it. That interface (again, simplifying slightly to remove distracting noise):

public interface IEnumerator
{
    bool MoveNext();
    T Current { get; }
}

So to loop through a list, you'd do this:

var e = list.GetEnumerator();
while (e.MoveNext())
{
    var item = e.Current;

    // blah
}

This pattern is captured neatly by the foreach keyword:

foreach (var item in list)
    // blah

But what about creating a new kind of list? Yes, we can just use List and fill it up with items. But what if we want to discover the items "on the fly" as they are requested? There is an advantage to this, which is that the client can abandon the iteration after the first three items, and they don't have to "pay the cost" of generating the whole list.

To implement this kind of lazy list by hand would be troublesome. We would have to write two classes, one to represent the list by implementing IEnumerable, and the other to represent an active enumeration operation by implementing IEnumerator.

Iterator methods do all the hard work for us. We just write:

IEnumerable GetNumbers(int stop)
{
    for (int n = 0; n < stop; n++)
        yield return n;
}

And the compiler converts this into two classes for us. Calling the method is equivalent to constructing an object of the class that represents the list.