Comment utiliser les attendent dans une boucle

Je suis en train de créer un asynchrones application console qui fait un peu de travail sur une collection. J'ai une version qui utilise la boucle for parallèle une autre version qui utilise async/await. Je m'attendais à la async/await version de travail similaire à la version parallèle, mais il s'exécute en mode synchrone. Ce que je fais mal?

class Program
{
    static void Main(string[] args)
    {
        var worker = new Worker();
        worker.ParallelInit();
        var t = worker.Init();
        t.Wait();
        Console.ReadKey();
    }
}

public class Worker
{
    public async Task<bool> Init()
    {
        var series = Enumerable.Range(1, 5).ToList();
        foreach (var i in series)
        {
            Console.WriteLine("Starting Process {0}", i);
            var result = await DoWorkAsync(i);
            if (result)
            {
                Console.WriteLine("Ending Process {0}", i);
            }
        }

        return true;
    }

    public async Task<bool> DoWorkAsync(int i)
    {
        Console.WriteLine("working..{0}", i);
        await Task.Delay(1000);
        return true;
    }

    public bool ParallelInit()
    {
        var series = Enumerable.Range(1, 5).ToList();
        Parallel.ForEach(series, i =>
        {
            Console.WriteLine("Starting Process {0}", i);
            DoWorkAsync(i);
            Console.WriteLine("Ending Process {0}", i);
        });
        return true;
    }
}
InformationsquelleAutor Satish | 2013-10-17
  1. 97

    La façon dont vous utilisez le await mot-clé indique C# que vous voulez attendre à chaque fois que vous passer à travers la boucle, ce qui n'est pas parallèle. Vous pouvez réécrire votre méthode de ce genre pour faire ce que vous voulez, en stockant une liste de Tasks et puis awaiting avec Tâche.WhenAll.

    public async Task<bool> Init()
{
    var series = Enumerable.Range(1, 5).ToList();
    var tasks = new List<Task<Tuple<int, bool>>>();
    foreach (var i in series)
    {
        Console.WriteLine("Starting Process {0}", i);
        tasks.Add(DoWorkAsync(i));
    }
    foreach (var task in await Task.WhenAll(tasks))
    {
        if (task.Item2)
        {
            Console.WriteLine("Ending Process {0}", task.Item1);
        }
    }
    return true;
}

public async Task<Tuple<int, bool>> DoWorkAsync(int i)
{
    Console.WriteLine("working..{0}", i);
    await Task.Delay(1000);
    return Tuple.Create(i, true);
}
    • Je ne sais pas pour les autres, mais un parallèle/foreach semble plus simple pour les boucles parallèles.
    • Important de noter que lorsque vous voyez le Ending Process notification n'est pas lorsque la tâche est en fait la fin. Toutes ces notifications sont sous-évaluées de façon séquentielle à droite après le dernier des tâches de finitions. Par le temps de vous voir "la Fin de Processus 1", 1 pourrait avoir été pendant une longue période de temps. Autres que le choix des mots, il y a, +1.
    • J'ai peut-être tort, mais une boucle parallèle des pièges de toute sorte de async résultat. En retournant une Tâche<T> vous obtenez immédiatement en arrière d'un objet Tâche dans laquelle vous pouvez gérer le travail qui se passe à l'intérieur comme à l'annuler ou de voir des exceptions. Maintenant avec Async/Await, vous pouvez travailler avec l'équipe d'objet dans une plus respectueuse de l' - c'est que vous n'avez pas à faire Tâche.Résultat.
    • S, et si je veux renvoyer une valeur avec asynchrone en fonction de l'utilisation des Tâches.WhenAll méthode?
    • Serait-ce une mauvaise pratique à mettre en œuvre un Semaphore dans DoWorkAsync à la durée maximale de l'exécution des tâches?
    InformationsquelleAutor Tim S.
  2. 31

    Votre code attend pour chaque opération (à l'aide de await) pour finir avant de commencer la prochaine itération.

    Par conséquent, vous n'obtenez pas de parallélisme.

    Si vous souhaitez exécuter un existant opération asynchrone en parallèle, vous n'avez pas besoin await; vous avez juste besoin d'obtenir une collection de Tasks et appel Task.WhenAll() pour retourner une tâche qui attend tous:

    return Task.WhenAll(list.Select(DoWorkAsync));
    • si vous ne pouvez pas utiliser toutes les méthodes asynchrones dans les boucles?
    • Vous pouvez. Cependant, await fait exactement le contraire de ce que vous voulez – attend pour la Task à la fin.
    • Je voulais accepter votre réponse, mais Tims S a une meilleure réponse.
    • Ou si vous n'avez pas besoin de savoir quand la tâche est terminée, vous pouvez simplement appeler les méthodes sans attendre pour eux
    • Pour confirmer ce que la syntaxe est en train de faire - c'est l'exécution de la Tâche appelée DoWorkAsync sur chaque élément list (en passant de chaque élément dans DoWorkAsync, ce qui je suppose a un seul paramètre)?
    InformationsquelleAutor SLaks
  3. 9
    public async Task<bool> Init()
{
    var series = Enumerable.Range(1, 5);
    Task.WhenAll(series.Select(i => DoWorkAsync(i)));
    return true;
}
    InformationsquelleAutor Vladimir
  4. -1

    Parfois, tous nous avons besoin est un copier + coller solution prête à l'emploi, donc, c'est l'ensemble de la solution de Tim.S.:

    namespace AsyncSimple
{
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
class Startup
{
static void Main()
{
var worker = new Worker();
worker.ParallelInit();
var t = worker.Init();
t.Wait();
Console.ReadKey();
}
}
public class Worker
{
public async Task<bool> Init()
{
var series = Enumerable.Range(1, 5).ToList();
var tasks = new List<Task<Tuple<int, bool>>>();
foreach (var i in series)
{
Console.WriteLine("Starting Process {0}", i);
tasks.Add(DoWorkAsync(i));
}
foreach (var task in await Task.WhenAll(tasks))
{
if (task.Item2)
{
Console.WriteLine("Ending Process {0}", task.Item1);
}
}
return true;
}
public async Task<Tuple<int, bool>> DoWorkAsync(int i)
{
Console.WriteLine("working..{0}", i);
await Task.Delay(1000);
return Tuple.Create(i, true);
}
public bool ParallelInit()
{
var series = Enumerable.Range(1, 5).ToList();
Parallel.ForEach(series, i =>
{
Console.WriteLine("Starting Process {0}", i);
DoWorkAsync(i);
Console.WriteLine("Ending Process {0}", i);
});
return true;
}
}
}

    Et le résultat dans la console:

    Comment utiliser les attendent dans une boucle

    InformationsquelleAutor