rendimiento rendimiento muchos?

Question

Me encuentro empeñando demasiado en IEnumerables solo para poder devolver cada resultado. ¿Hay alguna manera de comprimir algo como esto

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

Para quitar el foreach interno?

Answer 1

No, no hay, a menos que reemplace completamente cada yield return con una sola instrucción return usando LINQ.

Por ejemplo:

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

Answer 2

Uso Enumerable.SelectMany:

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

Esto sólo funciona si no tienen otras declaraciones de retorno de rendimiento en su método.

Answer 3

Esta es una característica requerida con frecuencia que C# no es compatible. Ver este artículo Connect para más detalles:

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

La sintaxis propuesta es generalmente algo como:

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 usted está interesado en jugar con un lenguaje C# -como compatible con esta característica, tomar una vistazo a Cω:

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

también podría querer leer este documento sobre t a función por los ejecutores de Cω:

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

Si está interesado en un idioma # -como no-C compatible con esta característica, echar un vistazo al "rendimiento" característica de F #. (Me encanta que el nombre de la función sea "yield!")

Incluso si no está interesado en lo teórico, parece que se enfrenta a esta situación como un problema práctico. También debe leer el artículo de Wes Dyer sobre técnicas para hacer eficientemente este tipo de iteración anidada sin "foreach rendimiento":

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

Answer 4

Usted puede romper su método en dos. Dados estos métodos de extensión:

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

Y utilizando de example Eric Lippert, se convierte en esto:

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

El método interno produce enumerables de T en lugar de Ts, y el método exterior sólo necesita para aplanar este resultado .

Answer 5

¡Utilice la potencia de Linq!

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