WaitAll vs WhenAll

Quelle est la différence entre Task.WaitAll() et Task.WhenAll() de la Async CTP ?
Pouvez-vous donner un exemple de code pour illustrer les différents cas d'utilisation ?

InformationsquelleAutor Yaron Levi | 2011-05-25

async-await asynchronous c#task-parallel-library

438

Task.WaitAll bloque le thread courant jusqu'à ce que tout est terminé.

Task.WhenAll renvoie une tâche qui représente l'action de l'attente jusqu'à ce que tout est terminé.

Qui signifie qu'à partir d'une méthode asynchrone, vous pouvez utiliser:
```
await Task.WhenAll(tasks);
```
... ce qui signifie que votre méthode continuera quand tout est terminé, mais vous ne pouvez pas attacher un fil à juste traîner jusqu'à cette date.
- Est-ce à assumer toutes les tâches que vous êtes en attente sur sont en train de travailler sur un autre thread?
- Autant que je sache, un nouveau sujet sera utilisé pour chaque tâche si nécessaire, le cadre obtiendrez le cadre de la code et si son opération de longue durée, alors probablement un nouveau fil de discussion sera utilisé.
- Après beaucoup de lecture, Il est clair que asynchrone n'a rien à voir avec les threads blog.stephencleary.com/2013/11/there-is-no-thread.html
- Je pense que "rien à voir avec les threads" est une exagération, et il est important de comprendre comment les opérations asynchrones interagir avec les threads.
- Je pense que la déclaration de await TaskEx.WhenAll(tasks) également bloquer le thread en cours ainsi.
- Non, il ne devrait pas bloc - y, c'est attendre la tâche retourné par WhenAll, mais ce n'est pas le même que le blocage du thread.
- Peut-être que le précise la distinction entre les deux est trop subtil pour moi. Pouvez-vous m'indiquer (et, éventuellement, le reste d'entre nous) à certains de référence qui permettra de faire clairement la différence?
- Pas vraiment, j'ai expliqué que bien que je peux déjà. Je suppose que je pourrais donner une analogie, c'est comme la différence entre la commande d'un repas à emporter et puis, debout près de la porte d'attente pour qu'il arrive, vs de commander un plat à emporter, faire d'autres choses et puis l'ouverture de la porte lorsque le courrier arrive...
- Merci, cela fait réellement de l'aide rendre les choses plus claires, au moins dans un sens abstrait.
- Salut pouvez-vous dire ce qui se passe pour les autres tâches prévues à la Tâche.WhenAny(liste des tâches) la fonction. - Ils continuer à s'exécuter en arrière-plan ou ils sont annulées/abandonné?
- Qu'ils continuent comme avant - il est assez commun pour attendre le premier à terminer, faire quelque chose, puis d'attendre la prochaine pour compléter etc.
- Merci pour la réponse rapide. Mais je veux que les autres tâches d'annuler immédiatement, car il peut prendre très longtemps et consomment des ressources système. Que puis-je faire pour cela?
- Assurez-vous que vous avez spécifié un jeton d'annulation pour chacune d'entre elles (en supposant qu'ils font un travail qui peut être annulé) et d'annuler le jeton pour chaque tâche qui n'est pas terminé.
- ils sont la création et l'écriture de fichiers. Donc, peut-il être annulé? et en général, comment .net décider si une tâche est peut être annulé ou pas?
- Eh bien, c'est ce code - que si la façon dont vous êtes en train de créer une tâche accepte un jeton d'annulation, et vérifie régulièrement, puis l'annulation de ce jeton doit annuler le travail. Je vous suggère de lire sur les jetons d'annulation sur le site MSDN.
InformationsquelleAutor Jon Skeet

Tout JonSkeet la réponse de explique la différence entre un excellent moyen pour moi la plus grande différence pratique est la gestion des exceptions. EDIT: d'Accord, c'est pas la plus pratique, la différence, c'est une différence.

Task.WaitAll jette un AggregateException lorsque l'une des tâches les lancers et vous pouvez examiner toutes les exceptions lancées. Le await dans await Task.WhenAll déballe le AggregateException et "revient", seule la première exception.

Lorsque le programme ci-dessous exécute avec await Task.WhenAll(taskArray) la sortie est comme suit.

19/11/2016 12:18:37 AM: Task 1 started
19/11/2016 12:18:37 AM: Task 3 started
19/11/2016 12:18:37 AM: Task 2 started
Caught Exception in Main at 19/11/2016 12:18:40 AM: Task 1 throwing at 19/11/2016 12:18:38 AM
Done.

Lorsque le programme ci-dessous est exécutée avec Task.WaitAll(taskArray) la sortie est comme suit.

19/11/2016 12:19:29 AM: Task 1 started
19/11/2016 12:19:29 AM: Task 2 started
19/11/2016 12:19:29 AM: Task 3 started
Caught AggregateException in Main at 19/11/2016 12:19:32 AM: Task 1 throwing at 19/11/2016 12:19:30 AM
Caught AggregateException in Main at 19/11/2016 12:19:32 AM: Task 2 throwing at 19/11/2016 12:19:31 AM
Caught AggregateException in Main at 19/11/2016 12:19:32 AM: Task 3 throwing at 19/11/2016 12:19:32 AM
Done.

Le programme:

class MyAmazingProgram
{
public class CustomException : Exception
{
public CustomException(String message) : base(message)
{ }
}
static void WaitAndThrow(int id, int waitInMs)
{
Console.WriteLine($"{DateTime.UtcNow}: Task {id} started");
Thread.Sleep(waitInMs);
throw new CustomException($"Task {id} throwing at {DateTime.UtcNow}");
}
static void Main(string[] args)
{
Task.Run(async () =>
{
await MyAmazingMethodAsync();
}).Wait();
}
static async Task MyAmazingMethodAsync()
{
try
{
Task[] taskArray = { Task.Factory.StartNew(() => WaitAndThrow(1, 1000)),
Task.Factory.StartNew(() => WaitAndThrow(2, 2000)),
Task.Factory.StartNew(() => WaitAndThrow(3, 3000)) };
Task.WaitAll(taskArray);
//await Task.WhenAll(taskArray);
Console.WriteLine("This isn't going to happen");
}
catch (AggregateException ex)
{
foreach (var inner in ex.InnerExceptions)
{
Console.WriteLine($"Caught AggregateException in Main at {DateTime.UtcNow}: " + inner.Message);
}
}
catch (Exception ex)
{
Console.WriteLine($"Caught Exception in Main at {DateTime.UtcNow}: " + ex.Message);
}
Console.WriteLine("Done.");
Console.ReadLine();
}
}

la plus grande différence est la gestion des exceptions. Vraiment? Parce que ce n'est vraiment pas la plus grande différence pratique. La plus grande différence pratique est un est asynchrone et non de blocage où comme les autres est le blocage. C'est beaucoup plus important que la façon dont il gère les exceptions.
Merci de souligner ce point. Cette explication a été utile dans le scénario que je suis en train de travailler. Peut-être pas la "plus grande différence pratique", mais certainement un bon appel.
La gestion des exceptions être plus pratique, la différence peut être plus applicable à la comparaison entre await t1; await t2; await t3; vs await Task.WhenAll(t1,t2,t3);
N'est-ce pas exception comportement en contradiction avec la docs ici (docs.microsoft.com/en-us/dotnet/api/...) "Si l'une des tâches termine dans un état faulted, le retour de l'tâche se termine dans un état Faulted, où ses exceptions contiendra l'agrégation de l'ensemble de déballer les exceptions de chacune des tâches."

InformationsquelleAutor tymtam

17

Comme un exemple de la différence, si vous avez une tâche à la fait quelque chose avec le thread d'INTERFACE utilisateur (par exemple, une tâche qui représente une animation dans un Storyboard) si vous Task.WaitAll() alors le thread d'INTERFACE utilisateur est bloqué et l'INTERFACE utilisateur n'est jamais mis à jour. si vous utilisez await Task.WhenAll() alors le thread d'INTERFACE utilisateur n'est pas bloqué, et l'INTERFACE utilisateur sera mis à jour.

InformationsquelleAutor J. Long
4

Ce qu'ils font:
- En interne à la fois faire la même chose.
Quelle est la différence:
- WaitAll est un appel bloquant
- WhenAll - pas - code de poursuivre l'exécution de
Utilisation qui, lorsqu':
- WaitAll quand ne peut pas continuer sans avoir le résultat
- WhenAll lors de ce qui vient d'être informé, pas bloqué
- Mais que faire si vous n'avez pas attendre il immédiatement, mais continuer avec quelques autres travaux et puis l'attendent? Vous n'avez pas cette possibilité avec WaitAll ce que je comprends.
InformationsquelleAutor i100

Vous devez vous connecter pour publier un commentaire.