Rendement Retour Beaucoup?

Question

Je me trouve souvent sur IEnumerables juste pour que je puisse retourner chaque résultat. Existe-t-il un moyen de compresser quelque chose comme ceci

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

Pour supprimer le foreach interne?

Answer 1

Non, à moins que vous remplaciez complètement chaque yield return par une seule instruction return utilisant LINQ.

Par exemple:

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

Answer 2

Utilisation Enumerable.SelectMany:

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

Cela ne fonctionne que si vous n'avez pas d'autres déclarations de retour de rendement dans votre méthode.

Answer 3

Il s'agit d'une fonctionnalité demandée fréquemment que C# ne prend pas en charge. Voir cet article Connect pour plus de détails:

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

La syntaxe proposée est quelque chose comme:

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

Si vous êtes intéressé à jouer avec un langage C# -comme qui prend en charge cette fonction, prendre regarder cQ:

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

Vous pouvez également lire cet article sur t il caractéristique par les implémenteurs de cQ:

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

Si vous êtes intéressé par une langue non-C# -comme qui prend en charge cette fonctionnalité, jetez un oeil à la « rendement! » caractéristique de F #. (J'adore que le nom de la fonctionnalité soit "rendement!")

Même si vous n'êtes pas intéressé par les choses théoriques, il semble que vous ayez à faire face à cette situation comme un problème pratique. Vous devriez également lire l'article de Wes Dyer sur les techniques de faire efficacement ce genre d'itération imbriquée sans « rendement foreach »:

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

Answer 4

Vous pouvez casser votre méthode en deux. Compte tenu de ces méthodes d'extension:

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

Et en utilisant de example Eric Lippert, il devient ceci:

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

La méthode intérieure donne enumerables de T au lieu de T, et la méthode externe a juste besoin d'aplatir ce résultat .

Answer 5

Utilisez la puissance de Linq!

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