Quel est le mécanisme recommandé de parallélisation des arbres d'expression?

Question

étant donné un scénario où je numérise & désargentant des arbres d'expression qui fonctionnent sur IEnumerable s pour l'extension de traitement distribué, je voudrais aussi automatiser l'échelle: Lors de l'exécution de cet arbre d'expression, je voudrais appliquer le TPL AsParallel() opérateur.

Quelle est la meilleure pratique pour ce faire?

Answer 1

Vous ne savez pas où votre problème est. Je suppose que vous voulez

IEnumerable<string> enumerable = new List<string>(); 
Expression<Func<IEnumerable<string>, IEnumerable<bool>>> expression = a => a.Select(b => b == true); 

Pour augmenter ou réduire automatiquement l'échelle. La chose est, AsParallel() retourne juste une classe qui implémente une méthode GetEnumerator() différente. Il fonctionne toujours sur une interface IEnumerable < T>. Alors, pourquoi ne pas implémenter

Expression<Func<ParallelQuery<TSource>, IEnumerable<bool>>> expression = a => a.Select(b => b == true); 

par défaut? Alors avoir quelque chose comme:

void Execute(Expression<Func<ParallelQuery<string>, IEnumerable<bool>>> expression, IEnumerable<string> strings) 
{ 
    ParallelQuery<string> parStrings; 
    if (!typeof (ParallelQuery<string>).IsAssignableFrom(strings.GetType())) 
     parStrings = strings as ParallelQuery<string>; 
    else 
     parStrings = strings.AsParallel(); 

    expression.Compile()(parStrings); 
} 

Longue histoire courte. Votre expression s'exécute sur ParallelQuery < T> par défaut, et convertit votre IEnumerable < T> en ParallelQuery < T>. Sinon, vous regardez la traversée de nœud/la recomposition de requête. (Je ne sais pas si cela répond à votre question, mais blabbers de toute façon.)

Juste une note d'avertissement Expression.Compile() est une méthode très lourde. Si vous voulez des performances, évitez-le si possible.