¿Cómo puedo recopilar valores devueltos de Parallel.ForEach?

Question

Llamo a un servicio web lento en paralelo. Las cosas fueron geniales hasta que me di cuenta de que necesitaba obtener algo de información del servicio. Pero no veo dónde recuperar los valores. No puedo escribir en la base de datos, HttpContext.Current parece ser nulo dentro de un método llamado usando Parallel.ForEach

A continuación se muestra un programa de ejemplo (en su mente, imagine un servicio web lento en lugar de una cadena de concatenación)

using System; 
using System.Threading.Tasks; 

class Program 
{ 
    static void Main(string[] args) 
    { 
     WordMaker m = new WordMaker(); 
     m.MakeIt(); 
    } 
    public class WordMaker 
    { 
     public void MakeIt() 
     { 
      string[] words = { "ack", "ook" }; 
      ParallelLoopResult result = Parallel.ForEach(words, word => AddB(word)); 
      Console.WriteLine("Where did my results go?"); 
      Console.ReadKey(); 
     } 
     public string AddB(string word) 
     { 
      return "b" + word; 
     } 
    } 

} 

Answer 1

Lo ha descartado aquí.

ParallelLoopResult result = Parallel.ForEach(words, word => AddB(word)); 

Es posible que desee algo así,

ParallelLoopResult result = Parallel.ForEach(words, word => 
{ 
    string result = AddB(word); 
    // do something with result 
}); 

Si desea algún tipo de recogida al final de esto, considerar el uso de una de las colecciones bajo System.Collections.Concurrent, como ConcurrentBag

var resultCollection = new ConcurrentBag<string>(); 
ParallelLoopResult result = Parallel.ForEach(words, word => 
{ 
    resultCollectin.Add(AddB(word)); 
}); 

// Do something with result 

Answer 2

No use ConcurrentBag para recopilar resultados, ya que es extremadamente lento. Use el bloqueo local en su lugar.

var resultCollection = new List<string>(); 
object localLockObject = new object(); 

Parallel.ForEach<string, List<string>>(
     words, 
    () => { return new List<string>(); }, 
     (word, state, localList) => 
     { 
     localList.Add(AddB(word)); 
     return localList; 
     }, 
     (finalResult) => { lock (localLockObject) resultCollection.AddRange(finalResult); } 
); 

// Do something with resultCollection here 

Answer 3

¿Qué tal algo como esto:

public class WordContainer 
{ 
    public WordContainer(string word) 
    { 
     Word = word; 
    } 

    public string Word { get; private set; } 
    public string Result { get; set; } 
} 

public class WordMaker 
{ 
    public void MakeIt() 
    { 
     string[] words = { "ack", "ook" }; 
     List<WordContainer> containers = words.Select(w => new WordContainer(w)).ToList(); 

     Parallel.ForEach(containers, AddB); 

     //containers.ForEach(c => Console.WriteLine(c.Result)); 
     foreach (var container in containers) 
     { 
      Console.WriteLine(container.Result); 
     } 

     Console.ReadKey(); 
    } 

    public void AddB(WordContainer container) 
    { 
     container.Result = "b" + container.Word; 
    } 
} 

creo que el bloqueo o de objetos concurrentes no es necesario a menos que necesite los resultados de interactuar unos con otros (como si estuviera calculando una suma o combinación todas las palabras). En este caso, ForEach divide cuidadosamente su lista original y le entrega a cada hilo su propio objeto para que pueda manipular todo lo que quiera sin preocuparse de interferir con los otros hilos.

Answer 4

Puede considerar el uso del método de extensión AsParallel de IEnumerable, se ocupará de la concurrencia y recopilará los resultados.

words.AsParallel().Select(AddB).ToArray()

de sincronización (por ejemplo, cerraduras o colecciones concurrentes que utilizan cerraduras) son generalmente cuello de botella de algoritmos concurrentes. Lo mejor es evitar la sincronización tanto como sea posible. Supongo que AsParallel usa algo más inteligente como colocar todos los elementos producidos en un hilo en una colección local no concurrente y luego combinarlos al final.

Answer 5

Esto parece segura, rápida y sencilla:

public string[] MakeIt() { 
     string[] words = { "ack", "ook" }; 
     string[] results = new string[words.Length]; 
     ParallelLoopResult result = 
      Parallel.For(0, words.Length, i => results[i] = AddB(words[i])); 
     return results; 
    }