How to handle an "infinite" IEnumerable?

A trivial example of an "infinite" IEnumerable would be

IEnumerable<int> Numbers() {
  int i=0;
  while(true) {
    yield return unchecked(i++);
  }
}

I know, that

foreach(int i in Numbers().Take(10)) {
  Console.WriteLine(i);
}

and

var q = Numbers();
foreach(int i in q.Take(10)) {
  Console.WriteLine(i);
}

both work fine (and print out the number 0-9).

But are there any pitfalls when copying or handling expressions like q? Can I rely on the fact, that they are always evaluat开发者_运维百科ed "lazy"? Is there any danger to produce an infinite loop?

As long as you only call lazy, un-buffered methods you should be fine. So Skip, Take, Select, etc are fine. However, Min, Count, OrderBy etc would go crazy.

It can work, but you need to be cautious. Or inject a Take(somethingFinite) as a safety measure (or some other custom extension method that throws an exception after too much data).

For example:

public static IEnumerable<T> SanityCheck<T>(this IEnumerable<T> data, int max) {
    int i = 0;
    foreach(T item in data) {
        if(++i >= max) throw new InvalidOperationException();
        yield return item;
    }
}

Yes, you are guaranteed that the code above will be executed lazily. While it looks (in your code) like you'd loop forever, your code actually produces something like this:

IEnumerable<int> Numbers()
{
    return new PrivateNumbersEnumerable();
}

private class PrivateNumbersEnumerable : IEnumerable<int>
{
    public IEnumerator<int> GetEnumerator() 
    { 
        return new PrivateNumbersEnumerator(); 
    }
}

private class PrivateNumbersEnumerator : IEnumerator<int>
{
    private int i;

    public bool MoveNext() { i++; return true; }   

    public int Current
    {
        get { return i; }
    }
}

(This obviously isn't exactly what will be generated, since this is pretty specific to your code, but it's nonetheless similar and should show you why it's going to be lazily evaluated).

You would have to avoid any greedy functions that attempt to read to end. This would include Enumerable extensions like: Count, ToArray/ToList, and aggregates Avg/Min/Max, etc.

There's nothing wrong with infinite lazy lists, but you must make conscious decisions about how to handle them.

Use Take to limit the impact of an endless loop by setting an upper bound even if you don't need them all.

Yes, your code will always work without infinite looping. Someone might come along though later and mess things up. Suppose they want to do:

var q = Numbers().ToList();

Then, you're hosed! Many "aggregate" functions will kill you, like Max().

If it wasn't lazy evaluation, your first example won't work as expected in the first place.