Allow C# to use anonymous iterators.

[mburbea]

VB.net allows you to have a lambda return an iterator, it should hopefully be possible to use such functionality in c#. E.g.

Func<IEnumerable<int>> f = ()=>yield return 3;

While that's a terrible example it hopefully can demonstrate the point.

[HaloFour]

The one Devil's advocate argument against that is that you wouldn't be able to tell that the lambda was an iterator unless you read through the contents of the body. In VB.NET they dedicated a new keyword Iterator which is a required component of the method signature in order for that method to be an iterator. This is also why C# has the async keyword for denoting methods (and lambdas) as asynchronous and allowing the use of await.

[SLaks]

@HaloFour Actually, the reason that C# needs the async keyword is that await x; is already valid code if you have a class named await.
yield return is never valid syntax, so there is no need for an iterator keyword.

[MadsTorgersen]

I'm somewhat suspicious of anonymous iterators as a feature. Think about how you would use one to actually start getting values out:

Func<IEnumerable<int>> iterator = () => { ... yield return some stuff ... };
var enumerable = iterator();
var enumerator = enumerable.GetEnumerator();
enumerator.MoveNext();
var actualElement = enumerator.Current;

I'm exaggerating a little here to draw out the number of steps it actually takes to unpack such an iterator lambda. That seems a little too far removed!

But think about it: you are rarely required to actually pass a Func<IEnumerable<T>> to anything. More likely you need to pass an IEnumerable<T>. So you would create an iterator delegate, execute it immediately and henceforth only use the result:

Func<IEnumerable<int>> iterator = () => { ... yield return some stuff ... };
SomeMethod(iterator()); // need to invoke the iterator. The delegate object itself is ignored

Maybe local functions (as discussed in #14) would be a slightly better approach. Here you could define an actual named iterator function inside your method body, and use the result of calling that:

IEnumerable<int> iterator() { ... yield return some stuff ... } // local iterator function
SomeMethod(iterator()); // still need to invoke the iterator, but there's no delegate object

Not perfect, but better than creating a delegate object just to immediately invoke and discard it.

[paulomorgado]

Other than the allocation and invocation of the delegate, what are the other benefits of local functions over lambdas or anonymous delegates?

As for the consuming source code, once you get the delegate, it's not much different than calling any method.

foreach(var item in (() => { ... yield return some stuff ... })())
{
    ...
}

I don't think I ever wanted to do that on production code. Usually it's some LINQ query over an existing enumerable. But for test code, that could be useful.

[SLaks]

Anonymous iterators would be more useful for SelectMany(); there have been a couple of times when I've needed to do that.

[MgSam]

I think the biggest benefit of anonymous iterators hasn't been mentioned yet, which is to combine the argument checking and iterator body into a single method.

public IEnumerable<T> Where<T>(this IEnumerable<T> enumerable, Func<T, bool> filter)
{
    if(enumerable == null) throw new ArgumentNullException();
    if(filter == null) throw new ArgumentNullException();

    Func<IEnumerable<T>, Func<T, bool>, IEnumerable<T>> iter = (enumerable, filter) => 
    {
          foreach(var item in enumerable)
              if(filter(item)) yield return item;
    }
    return iter(enumerable, filter);
}

Much nicer than having separate methods. A local named function would also work well.

[orthoxerox]

Yes, I agree they would be good for SelectMany. Sometimes you don't have the new sequence ready for you, and generating it using an external generator is complicated by the source being an anonymous type, so you can't really pass it outside.

For example, I had to generate a frequency dictionary of three-letter sequences out of a frequency dictionary of words, so I had a IEnumerable<{string Word, double Freq}> words after parsing the file. Of course there was a LINQy way: words.Where(w=>w.Word.Length>=3).SelectMany(w=>Enumerable.Range(0,w.Word.Length-2).Select(i=>new {Word = w.Word.Substring(i,3), Freq = w.Freq}));, and I could've passed only w.Word into the external generator and then projected the resulting sequence (that's actually what I've done), but my first impulse was to put a generator lambda with a for loop inside SelectMany, as that would be the clearest explanation of the algorithm.