Yield Return Many?

Question

I find myself foreach-ing over IEnumerables a lot just so that I can return each result. Is there a way to compress something like this

foreach (var subSelector in subSelectors)
{
    foreach (var node in FindSingle(context, subSelector))
        yield return node;
} 

To remove the inner foreach?

Answer 1

This is a somewhat frequently requested feature that C# does not support. See this Connect item for details:

http://connect.microsoft.com/VisualStudio/feedback/details/256934/yield-return-to-also-yield-collections

The proposed syntax is usually something like:

public static IEnumerable<T> PreorderTraversal<T>(this BinaryTree<T> root)
{
    if (root == null) yield break;
    yield return root.Item;
    yield foreach root.Left.PreorderTraversal();
    yield foreach root.Right.PreorderTraversal();
}

If you are interested in playing with a C#-like language that supports this feature, take a look at Cω:

http://research.microsoft.com/en-us/um/cambridge/projects/comega/

You might also want to read this paper on the feature by the implementors of Cω:

http://research.microsoft.com/en-us/projects/specsharp/iterators.pdf

If you're interested in a non-C#-like language that supports this feature, take a look at the "yield!" feature of F#. (I just love that the name of the feature is "yield!")

Even if you are not interested in the theoretical stuff, it sounds like you face this situation as a practical problem. You should also read Wes Dyer's article on techniques for efficiently doing this sort of nested iteration without "yield foreach":

http://blogs.msdn.com/b/wesdyer/archive/2007/03/23/all-about-iterators.aspx

Answer 2

No, there isn't, unless you completely replace every yield return with a single return statement using LINQ.

For example:

return someSet
    .Concat(someOtherSet.SelectMany(s => FindSingle(context, s));

Answer 3

With C# 7.0, local functions are allowed, which enables us to have a fairly neat approach

IEnumerable<T> FlatEnumerable(){
    IEnumerable<IEnumerable<T>> NestedEnumerable(){
       yield return myEnumerable1;
       yield return myEnumerable2;
    }

    return NestedEnumerable().SelectMany(e => e);
}

https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/local-functions

Answer 4

Use Enumerable.SelectMany:

return subSelectors.SelectMany(subselector => FindSingle(context, subSelector));

This only works if you don't have any other yield return statements in your method.

Answer 5

You can break your method into two. Given these extension methods:

public static class MultiEnumerableExtensions {
  public static IEnumerable<T> Pack<T>(this T item) {
    yield return item;
  }
  public static IEnumerable<T> Flatten<T>(
    this IEnumerable<IEnumerable<T>> multiList) {
    return multiList.SelectMany(x => x);
  }
}

And using Eric Lippert's example, it becomes this:

public static class BinaryTreeExtensions {
  public static IEnumerable<T> PreorderTraversal<T>(this BinaryTree<T> root) {
    return PreorderTraversalMulti(root).Flatten();
  }
  private static IEnumerable<IEnumerable<T>> PreorderTraversalMulti<T>(
    this BinaryTree<T> root) {
    if (root == null) yield break;
    yield return root.Item.Pack(); // this packs an item into an enumerable
    yield return root.Left.PreorderTraversal();
    yield return root.Right.PreorderTraversal();
  }
}

The inner method yields enumerables of T instead of Ts, and the outer method just needs to flatten this result.

Answer 6

Use the power of Linq!

return subSelectors.SelectMany(s => FindSingle(context, s));

Answer 7

Combining @Jordao's answer and the fact that C#7 contains local functions, as @Oskar mentiond I think the following would be the "updated" answer:

        public static IEnumerable<T> PreorderTraversal<T>(this BinaryTree<T> root)
        {
            IEnumerable<IEnumerable<T>> PreorderTraversalMulti<T>(
          this BinaryTree<T> root)
            {
                if (root == null) yield break;
                yield return root.Item.Pack(); // this packs an item into an enumerable
                yield return root.Left.PreorderTraversal();
                yield return root.Right.PreorderTraversal();
            }
            return PreorderTraversalMulti.Concat( PreorderTraversalMulti(root).Flatten());
        }

I used this for a different reason - to get all files up to 3 stages inside and finalized with this function:

public static IEnumerable<FileInfo> EnumerateFiles(DirectoryInfo sourceFolder, string pattern, int steps2Enter, int currStep = 0, int maximumNumFiles = 800)
    {
        int total = 0;
        IEnumerable<FileInfo> NestedFunc()
        {
            if (currStep > steps2Enter) yield break;
            if (sourceFolder == null) yield break;
            foreach (var file in sourceFolder.GetFiles(pattern, SearchOption.TopDirectoryOnly))
            {
                if (total++ > maximumNumFiles) yield break;
                yield return file;
            }
        }
        return NestedFunc().Concat(sourceFolder.EnumerateDirectories().SelectMany(s => EnumerateFiles(s, pattern, steps2Enter, currStep + 1, maximumNumFiles)));
    }

So yes - I'm still waiting for some syntatic sugar which will enable writing

yield return foreach...