Optimisation: Comment optimiser la concaténation Linq des collections? C#

Question

est-il possible que je peux optimiser ceci:

public static IEnumerable<IEnumerable<int>> GenerateCombinedPatterns 
    (IEnumerable<IEnumerable<int>> patterns1, 
    IEnumerable<IEnumerable<int>> patterns2) 
{ 
    return patterns1 
      .Join(patterns2, p1key => 1, p2key => 1, (p1, p2) => p1.Concat(p2)) 
      .Where(r => r.Sum() <= stockLen) 
      .AsParallel() 
     as IEnumerable<IEnumerable<int>>; 
} 

Answer 1

Si vous êtes à la recherche pour chaque combinaison, utilisez plutôt SelectMany, généralement effectué avec de multiples « de » clauses:

return from p1 in patterns1 
     from p2 in patterns2 
     let combination = p1.Concat(p2) 
     where combination.Sum() <= stockLen 
     select combination; 

C'est sans aucun parallélisme si ... en fonction des collections attendues, Je probablement juste paralléliser à un niveau, par exemple

return from p1 in patterns1.AsParallel() 
     from p2 in patterns2 
     let combination = p1.Concat(p2) 
     where combination.Sum() <= stockLen 
     select combination; 

Notez qu'il n'y a aucune garantie quant à l'ordre dans lequel les résultats sortent au-dessus - vous auriez besoin de ruser si vous vouliez la commande originale.

Answer 2

Aucun point à faire le parallèle de requête à la fin. Mise à jour: Jon avait raison, ma solution initiale était incorrecte et s'avère que ma solution corrigée était essentiellement la même que la sienne.

public static IEnumerable<IEnumerable<int>> GenerateCombinedPatterns 
    (IEnumerable<IEnumerable<int>> patterns1, 
    IEnumerable<IEnumerable<int>> patterns2) 
{ 
    var parallel1 = patterns1.AsParallel(); 
    return parallel1.SelectMany(p1 => patterns2.Select(p2 => p1.Concat(p2))) 
     .Where(r => r.Sum() <= stockLen); 
}