CODEWITHSUNDEEP
c#enumerationinfinite-loopyield-return
Danvil
Danvil

Reputation: 22991

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 evaluated "lazy"? Is there any danger to produce an infinite loop?

Upvotes: 30

Views: 7429

Answers (5)

Adam Robinson
Adam Robinson

Reputation: 185643

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).

Upvotes: 9

Ron Klein
Ron Klein

Reputation: 9440

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

Upvotes: 0

Patrick Karcher
Patrick Karcher

Reputation: 23603

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().

Upvotes: 2

spoulson
spoulson

Reputation: 21591

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.

Upvotes: 5

Marc Gravell
Marc Gravell

Reputation: 1062745

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;
    }
}

Upvotes: 23

Related Questions