L'Utilisation De La Tâche.WaitAll() pour gérer attendu tâches?

Idéalement ce que je veux faire est de retarder une tâche avec un non-mode de blocage, puis attendez que toutes les tâches à effectuer. J'ai essayé d'ajouter la tâche de l'objet retourné par la Tâche.Retard et ensuite utiliser Tâche.WaitAll mais il semble que cela ne va pas aider. Comment dois-je résoudre ce problème?

class Program
{
    public static async void Foo(int num)
    {
        Console.WriteLine("Thread {0} - Start {1}", Thread.CurrentThread.ManagedThreadId, num);

        var newTask = Task.Delay(1000);
        TaskList.Add(newTask);
        await newTask;

        Console.WriteLine("Thread {0} - End {1}", Thread.CurrentThread.ManagedThreadId, num);
    }

    public static List<Task> TaskList = new List<Task>();

    public static void Main(string[] args)
    {
        for (int i = 0; i < 3; i++)
        {
            int idx = i;
            TaskList.Add(Task.Factory.StartNew(() => Foo(idx)));
        }

        Task.WaitAll(TaskList.ToArray());
    }
}
  • Pourquoi faites-vous cela dans une Application Console? Il n'y a pas de contexte (par défaut), donc await a tendance à se comporter étrangement, de toute façon...
  • Quels sont exactement vous attendent à voir dans la console? Comment est-ce différent de ce que vous voyez?
  • Ce que j'attends de voir sont six lignes montrant à la fois Début et de Fin de chaque tâche. Mais pour l'instant, j'en vois seulement de Commencer...
  • Votre code semble fonctionner pour moi ... (s'exécutant dans un wpf solution, mais encore, le code fonctionne, une fois que la fin s'exécute sur le thread GUI...)
  • async void méthode que vous passez à Task.Factory.StartNew est une mauvaise idée. Vous ne pouvez pas garder une trace de la tâche en attente, il commence ou attraper toutes les exceptions qu'il peut jeter après await. Cochez cette pour plus d'info: stackoverflow.com/q/19747910/1768303
InformationsquelleAutor derekhh | 2013-11-08
  1. 42

    Est-ce que vous essayez d'atteindre?

    using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication
{
    class Program
    {
        public static async Task Foo(int num)
        {
            Console.WriteLine("Thread {0} - Start {1}", Thread.CurrentThread.ManagedThreadId, num);

            await Task.Delay(1000);

            Console.WriteLine("Thread {0} - End {1}", Thread.CurrentThread.ManagedThreadId, num);
        }

        public static List<Task> TaskList = new List<Task>();

        public static void Main(string[] args)
        {
            for (int i = 0; i < 3; i++)
            {
                int idx = i;
                TaskList.Add(Foo(idx));
            }

            Task.WaitAll(TaskList.ToArray());
            Console.WriteLine("Press Enter to exit...");
            Console.ReadLine();
        }
    }
}

    De sortie:

    Fil 10 - Start 0 
Fil 10 - 1 
Fil 10 - Start 2 
Fil 6 - 0 
Fil 6 - 2 
Fil 6 - 1 
Appuyez sur Entrée pour quitter...
    • Pas vraiment. Ce serait seulement la sortie de la première des trois "Start ..." lignes et ne sera pas de sortie "de la Fin ...". Cela signifie que ces tâches n'ai pas vraiment terminé (enfin, je comprends la nouvelle tâche de la création d'objets au lieu de l'original sont ajoutés à la liste des tâches). Donc, j'avais vraiment envie de trouver un moyen qui peut se comporter correctement et de montrer que ces trois tâches sont terminées.
    • avez-vous essayé? J'ai posté un exemple complet. Vous voyez Commencer/Commencer/Commencer, parce que vous commencez tâches en parallèle. Il est correspondant à la Fin de chacune des tâches. Ou voulez-vous de les lancer l'un après l'autre?
    • Merci! J'ai juste remarqué que vous avez aussi changé le type de retour de Foo de void à la Tâche. Oui, en changeant ce retour serait de voir exactement le même comportement que vous avez écrit. 🙂
    • yep, voir mes commentaires à votre question à propos de async void. Aussi, assurez-vous de lire Stephen Toub du blog ce qui concerne l'imbrication des tâches, c'est très instructif.
    InformationsquelleAutor noseratio
  2. 20

    La chose à prendre en compte est que parce que Foo est asynchrone, il est lui-même une Tâche. Votre exemple a des tâches qui, tout simplement, le coup d'envoi de la Foo tâche, mais n'attendez pas pour cela.

    En d'autres termes, Task.WaitAll(TaskList.ToArray()) est simplement en attente pour chaque Task.Delay pour commencer, mais il n'est pas d'attente pour l'ensemble de ces tâches pour terminer.

    Ce pourrait bien être ce que vous essayez d'atteindre:

    class Program
{
    public static async Task Foo(int num)
    {
        Console.WriteLine("Thread {0} - Start {1}", Thread.CurrentThread.ManagedThreadId, num);

        var newTask = Task.Delay(1000);

        await newTask;
        Console.WriteLine("Thread {0} - End {1}", Thread.CurrentThread.ManagedThreadId, num);

    }

    public static List<Task> TaskList = new List<Task>();

    public static void Main(string[] args)
    {
        for (int i = 0; i < 3; i++)
        {
            int idx = i;

            Task fooWrappedInTask = Task.Run(() => Foo(idx));
            TaskList.Add(fooWrappedInTask);
        }

        Task.WaitAll(TaskList.ToArray());
        Console.WriteLine("Finished waiting for all of the tasks: - Thread {0}", Thread.CurrentThread.ManagedThreadId);
    }
}

    J'ai testé, et il produit la sortie de la console que vous visez.

    La principale différence ici est que nous allons appeler Task.Run au lieu de Task.Factory.StartNew.

    Vous pourriez avoir un Task qui renvoie un Task, qui pourrait revenir un autre Task. On pourrait penser à cela comme une "chaîne" des tâches.

    Task.Run renvoie une Task qui représentent la tâche finale de la chaîne. Lorsque vous attendez pour cela, vous êtes en attente pour la chaque maillon de la chaîne de tâches à réaliser.

    En comparaison, Task.Factory.StartNew retourne une tâche qui représente le premier maillon de la chaîne. Après avoir attendu pour elle, vous êtes de gauche avec le reste de la chaîne d'attendre. C'est bien dans la grande majorité des cas où la Task renvoie à quelque chose qui n'est pas un autre Task.

    • Vous créer des listes de tâches ici, qui Task.Run automatiquement le déballe, ce qui est inutile, de l'OMI. Sinon, le code semble pas être différente de la version que j'ai proposée. Ne sais pas si c'est ce que l'OP veut.
    InformationsquelleAutor Andrew Shepherd