Parallel.ForEach vs Task.Run e Task.WhenAll

Quais são as diferenças entre usar Parallel.ForEach ou Task.Run () para iniciar um conjunto de tarefas de forma assíncrona?

Versão 1:

List<string> strings = new List<string> { "s1", "s2", "s3" };
Parallel.ForEach(strings, s =>
{
    DoSomething(s);
});

Versão 2:

List<string> strings = new List<string> { "s1", "s2", "s3" };
List<Task> Tasks = new List<Task>();
foreach (var s in strings)
{
    Tasks.Add(Task.Run(() => DoSomething(s)));
}
await Task.WhenAll(Tasks);

Nesse caso, o segundo método aguardará assincronamente a conclusão das tarefas, em vez de o bloquear.

No entanto, há uma desvantagem a ser usada Task.Runem um loop - Com Parallel.ForEach, existe uma Partitionerque é criada para evitar a realização de mais tarefas do que o necessário. Task.Runsempre criará uma única tarefa por item (já que você está fazendo isso), mas os Parallellotes da classe funcionam para que você crie menos tarefas que o total de itens de trabalho. Isso pode proporcionar um desempenho geral significativamente melhor, especialmente se o corpo do loop tiver uma pequena quantidade de trabalho por item.

Se for esse o caso, você pode combinar as duas opções escrevendo:

await Task.Run(() => Parallel.ForEach(strings, s =>
{
    DoSomething(s);
}));

Observe que isso também pode ser escrito neste formato mais curto:

await Task.Run(() => Parallel.ForEach(strings, DoSomething));

A primeira versão bloqueará de forma síncrona o segmento de chamada (e executará algumas das tarefas nele).
Se for um thread da interface do usuário, isso congelará a interface do usuário.

A segunda versão executará as tarefas de forma assíncrona no pool de threads e liberará o thread de chamada até que elas sejam concluídas.

Também existem diferenças nos algoritmos de agendamento utilizados.

Observe que seu segundo exemplo pode ser reduzido para

await Task.WhenAll(strings.Select(s => Task.Run(() => DoSomething(s)));

Acabei fazendo isso, pois parecia mais fácil ler:

  List<Task> x = new List<Task>();
  foreach(var s in myCollectionOfObject)
  {
      // Note there is no await here. Just collection the Tasks
      x.Add(s.DoSomethingAsync());
  }
  await Task.WhenAll(x);

Eu vi Parallel.ForEach usado de forma inadequada e achei que um exemplo nesta pergunta ajudaria.

Ao executar o código abaixo em um aplicativo de console, você verá como as tarefas executadas no Parallel.ForEach não bloqueiam o segmento de chamada. Isso pode ser bom se você não se importar com o resultado (positivo ou negativo), mas se precisar do resultado, certifique-se de usar o Task.WhenAll.

using System;
using System.Linq;
using System.Threading.Tasks;

namespace ParrellelEachExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var indexes = new int[] { 1, 2, 3 };

            RunExample((prefix) => Parallel.ForEach(indexes, (i) => DoSomethingAsync(i, prefix)),
                "Parallel.Foreach");

            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("*You'll notice the tasks haven't run yet, because the main thread was not blocked*");
            Console.WriteLine("Press any key to start the next example...");
            Console.ReadKey();

            RunExample((prefix) => Task.WhenAll(indexes.Select(i => DoSomethingAsync(i, prefix)).ToArray()).Wait(),
                "Task.WhenAll");
            Console.WriteLine("All tasks are done.  Press any key to close...");
            Console.ReadKey();
        }

        static void RunExample(Action<string> action, string prefix)
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine($"{Environment.NewLine}Starting '{prefix}'...");
            action(prefix);
            Console.WriteLine($"{Environment.NewLine}Finished '{prefix}'{Environment.NewLine}");
        }


        static async Task DoSomethingAsync(int i, string prefix)
        {
            await Task.Delay(i * 1000);
            Console.WriteLine($"Finished: {prefix}[{i}]");
        }
    }
}

Aqui está o resultado:

Conclusão:

Usar o Parallel.ForEach com uma tarefa não bloqueará o thread de chamada. Se você se importa com o resultado, aguarde as tarefas.

~ Felicidades