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?
This is a somewhat frequently requested feature that C# does not support. See this Connect item for details:
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
yield each would sound better. Thanks for the answer! This is interesting.
yield as a class name, and each as a variable name, so there could be code containing the words yield each already. Now c# can determine that yield in yield return is a keyword because it is followed by another keyword; so in a similar vein yield foreach might be better.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)); 
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); } 
return subSelectors.SelectMany(subselector => FindSingle(context, subSelector)); This only works if you don't have any other yield return statements in your method.
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.
Use the power of Linq!
return subSelectors.SelectMany(s => FindSingle(context, s)); 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... 