ne peut pas attendre lambda asynchrone

De considérer cela, 

Task task = new Task (async () =>{
    await TaskEx.Delay(1000);
});
task.Start();
task.Wait();

L'appel de la tâche.Wait() ne fait pas attendre l'achèvement de la tâche et la ligne suivante est exécutée immédiatement, mais si j'enveloppe la async expression lambda dans un appel de méthode, le code fonctionne comme prévu.

private static async Task AwaitableMethod()
{
    await TaskEx.Delay(1000);    
}

ensuite (mis à jour en fonction des commentaires de svick)

await AwaitableMethod();
  • Dans le AwaitableMethod vous sont effectivement de retour et en appelant à Attendre sur la tâche retourné à partir de la .Delay (), méthode (je suis en supposant qu'elle renvoie une Task). Dans le lambda asynchrone vous appelez à Attendre sur la Task task. Mais encore, je n'ai pas d'explication.
  • Vous devriez être très prudent sur le mélange await avec Wait(). Dans de nombreux cas, cela peut conduire à des blocages.
  • trouvé un grand exemple sur le mélange await avec Wait()
InformationsquelleAutor kennyzx | 2012-10-24
  1. 82

    Dans votre lambda exemple, lorsque vous appelez task.Wait(), vous êtes en attente sur la nouvelle Tâche que vous avez construit, pas le délai de la Tâche dont il retourne. Pour obtenir votre choix de retard, vous devez également attendre sur la Tâche:

    Task<Task> task = new Task<Task>(async () => {
    await Task.Delay(1000);
});
task.Start();
task.Wait(); 
task.Result.Wait();

    Vous pouviez éviter de construire une nouvelle Tâche, et juste avoir une Tâche à traiter au lieu de deux:

    Func<Task> task = async () => {
    await TaskEx.Delay(1000);
};
task().Wait();
    • Je recommande fortement la lecture de pièges à éviter lors du passage autour de async lambdas et Tâche.Run vs Tâche.Usine.StartNew.
    • Si les premiers attendent est après beaucoup de traitement, vous pouvez toujours les doubles tâches. Au lieu de task.Result.Wait() vous pouvez également faire task.Unwrap().Wait() (ou Unwrap<T>() pour les non-méthodes void). La nouvelle Task.Run méthodes automatiquement déballer de sorte que vous n'attendez que sur la tâche.
    • En tant que débutant, j'ai l'impression qu'ils auraient pu faire un meilleur travail avec l' async de mots-clés; il est très déroutant.
    • Est-il possible de démarrer le conteneur tâche sans démarrage de la tâche imbriqués?
    • async s'attend à des fonctions de retour "à Chaud" les tâches à être retournée par les fonctions qui sont déjà commencé. Si vous attendez une tâche qui n'a pas commencé, et ne sera pas démarré, le programme ne sera jamais revenir de l'attendent. La seule façon de "ne pas démarrer la tâche imbriqués" est tout dans le récipient de la fonction à ne jamais appeler la fonction interne qui crée la tâche imbriqués.
    InformationsquelleAutor Joe Daley
  2. 6

    Vous devez utiliser TaskEx.RunEx.

    Il prend nativement en charge l'exécution de async méthodes sur la TaskPool par l'attente de l'intérieur de la tâche en interne. Sinon, vous rencontrerez le problème auquel vous êtes confronté, où seul l'extérieur de la tâche est attendu, qui, évidemment, se termine immédiatement, laissant une tâche qui doit encore en attente, ou dans votre cas (et même pire) un vide lambda qui ne peut pas être attendu.

    Sinon, vous pouvez attendre la tâche deux fois, vous permettant de construire votre extérieur tâche correctement (ce qui actuellement vous n'êtes pas).

    Code actuel (fixe):

    Task task = new Task<Task>(async () =>{
    await TaskEx.Delay(1000);
});

task.Start();
var innerTask = await task;
await innerTask;

    À L'Aide De TaskEx.RunEx:

    Task task = TaskEx.RunEx(async () =>{ //Framework awaits your lambda internally.
    await TaskEx.Delay(1000);
});

await task;
    • Belle explication, mais le code TaskEx.Exécuter ne fonctionne pas, a toujours le même problème.
    • Argh, désolé! Je suis en utilisant .NET 4.5... je voulais écrire TaskEx.RunEx. Comparer sa signature à TaskEx.Exécutez - vous verrez pourquoi c'est spécialement pour la course de méthodes asynchrones.
    InformationsquelleAutor Lawrence Wagerfield