En attente de plusieurs tâches avec des résultats différents

J'ai 3 tâches:

private async Task<Cat> FeedCat() {}
private async Task<House> SellHouse() {}
private async Task<Tesla> BuyCar() {}

Ils doivent tous s'exécuter avant que mon code puisse continuer et j'ai également besoin des résultats de chacun. Aucun des résultats n'a rien en commun les uns avec les autres

Comment puis-je appeler et attendre la fin des 3 tâches, puis obtenir les résultats?

Après utilisation WhenAll, vous pouvez extraire les résultats individuellement avec await:

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

await Task.WhenAll(catTask, houseTask, carTask);

var cat = await catTask;
var house = await houseTask;
var car = await carTask;

Vous pouvez également utiliser Task.Result(puisque vous savez à ce stade, ils ont tous réussi). Cependant, je recommande d'utiliser awaitcar c'est clairement correct, alors que cela Resultpeut causer des problèmes dans d'autres scénarios.

Juste awaitles trois tâches séparément, après les avoir toutes démarrées.

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

var cat = await catTask;
var house = await houseTask;
var car = await carTask;

Si vous utilisez C # 7, vous pouvez utiliser une méthode d'emballage pratique comme celle-ci ...

public static class TaskEx
{
    public static async Task<(T1, T2)> WhenAll<T1, T2>(Task<T1> task1, Task<T2> task2)
    {
        return (await task1, await task2);
    }
}

... pour activer une syntaxe pratique comme celle-ci lorsque vous souhaitez attendre plusieurs tâches avec différents types de retour. Il faudrait bien sûr faire plusieurs surcharges pour différents nombres de tâches à attendre.

var (someInt, someString) = await TaskEx.WhenAll(GetIntAsync(), GetStringAsync());

Cependant, consultez la réponse de Marc Gravell pour quelques optimisations autour de ValueTask et des tâches déjà terminées si vous avez l'intention de transformer cet exemple en quelque chose de réel.

Étant donné trois tâches - FeedCat(), SellHouse()et BuyCar(), il y a deux cas intéressants: soit ils se terminent tous de manière synchrone (pour une raison quelconque, peut-être la mise en cache ou une erreur), soit ils ne le font pas.

Disons que nous avons, à partir de la question:

Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = SellHouse();
    Task<Tesla> z = BuyCar();
    // what here?
}

Maintenant, une approche simple serait:

Task.WhenAll(x, y, z);

mais ... ce n'est pas pratique pour traiter les résultats; nous voudrions généralement await:

async Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = SellHouse();
    Task<Tesla> z = BuyCar();

    await Task.WhenAll(x, y, z);
    // presumably we want to do something with the results...
    return DoWhatever(x.Result, y.Result, z.Result);
}

mais cela fait beaucoup de surcharge et alloue divers tableaux (y compris le params Task[]tableau) et listes (en interne). Cela fonctionne, mais ce n'est pas génial IMO. À bien des égards, il est plus simple d'utiliser une asyncopération et awaitchacune à son tour:

async Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = SellHouse();
    Task<Tesla> z = BuyCar();

    // do something with the results...
    return DoWhatever(await x, await y, await z);
}

Contrairement à certains des commentaires ci-dessus, l'utilisation awaitau lieu de neTask.WhenAll fait aucune différence sur la façon dont les tâches s'exécutent (simultanément, séquentiellement, etc.). Au plus haut niveau, il Task.WhenAll est antérieur au bon support du compilateur pour async/ awaitet était utile lorsque ces choses n'existaient pas . Il est également utile lorsque vous avez un tableau arbitraire de tâches, plutôt que 3 tâches discrètes.

Mais: nous avons toujours le problème que async/ awaitgénère beaucoup de bruit de compilation pour la suite. S'il est probable que les tâches puissent effectivement se terminer de manière synchrone, nous pouvons optimiser cela en créant un chemin synchrone avec une solution de secours asynchrone:

Task<string> DoTheThings() {
    Task<Cat> x = FeedCat();
    Task<House> y = SellHouse();
    Task<Tesla> z = BuyCar();

    if(x.Status == TaskStatus.RanToCompletion &&
       y.Status == TaskStatus.RanToCompletion &&
       z.Status == TaskStatus.RanToCompletion)
        return Task.FromResult(
          DoWhatever(a.Result, b.Result, c.Result));
       // we can safely access .Result, as they are known
       // to be ran-to-completion

    return Awaited(x, y, z);
}

async Task Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) {
    return DoWhatever(await x, await y, await z);
}

Cette approche de "chemin de synchronisation avec repli asynchrone" est de plus en plus courante, en particulier dans le code haute performance où les exécutions synchrones sont relativement fréquentes. Notez que cela n'aidera pas du tout si l'achèvement est toujours véritablement asynchrone.

Autres choses qui s'appliquent ici:

1. avec C # récent, un modèle commun est que la asyncméthode de secours est généralement implémentée en tant que fonction locale:

   Task<string> DoTheThings() {
       async Task<string> Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) {
           return DoWhatever(await a, await b, await c);
       }
       Task<Cat> x = FeedCat();
       Task<House> y = SellHouse();
       Task<Tesla> z = BuyCar();
   
       if(x.Status == TaskStatus.RanToCompletion &&
          y.Status == TaskStatus.RanToCompletion &&
          z.Status == TaskStatus.RanToCompletion)
           return Task.FromResult(
             DoWhatever(a.Result, b.Result, c.Result));
          // we can safely access .Result, as they are known
          // to be ran-to-completion
   
       return Awaited(x, y, z);
   }

2. préfèrent ValueTask<T>à Task<T>s'il y a une bonne chance de choses jamais tout à fait synchrone avec beaucoup de différentes valeurs de retour:

   ValueTask<string> DoTheThings() {
       async ValueTask<string> Awaited(ValueTask<Cat> a, Task<House> b, Task<Tesla> c) {
           return DoWhatever(await a, await b, await c);
       }
       ValueTask<Cat> x = FeedCat();
       ValueTask<House> y = SellHouse();
       ValueTask<Tesla> z = BuyCar();
   
       if(x.IsCompletedSuccessfully &&
          y.IsCompletedSuccessfully &&
          z.IsCompletedSuccessfully)
           return new ValueTask<string>(
             DoWhatever(a.Result, b.Result, c.Result));
          // we can safely access .Result, as they are known
          // to be ran-to-completion
   
       return Awaited(x, y, z);
   }

3. si possible, préférer IsCompletedSuccessfullyà Status == TaskStatus.RanToCompletion; cela existe maintenant dans .NET Core pour Task, et partout pourValueTask<T>

Vous pouvez les stocker dans des tâches, puis les attendre tous:

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

await Task.WhenAll(catTask, houseTask, carTask);

Cat cat = await catTask;
House house = await houseTask;
Car car = await carTask;

Dans le cas où vous essayez de consigner toutes les erreurs, assurez-vous de conserver la ligne Task.WhenAll dans votre code, de nombreux commentaires suggèrent que vous pouvez le supprimer et attendre des tâches individuelles. Task.WhenAll est vraiment important pour la gestion des erreurs. Sans cette ligne, vous laissez potentiellement votre code ouvert pour les exceptions non observées.

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

await Task.WhenAll(catTask, houseTask, carTask);

var cat = await catTask;
var house = await houseTask;
var car = await carTask;

Imagine FeedCat lève une exception dans le code suivant:

var catTask = FeedCat();
var houseTask = SellHouse();
var carTask = BuyCar();

var cat = await catTask;
var house = await houseTask;
var car = await carTask;

Dans ce cas, vous n'attendrez jamais sur houseTask ni carTask. Il y a 3 scénarios possibles ici:

1. SellHouse est déjà terminé avec succès lorsque FeedCat a échoué. Dans ce cas, tout va bien.

2. SellHouse n'est pas terminée et échoue avec exception à un moment donné. Aucune exception n'est observée et sera renvoyée sur le thread du finaliseur.

3. SellHouse n'est pas terminée et contient des attentes à l'intérieur. Dans le cas où votre code s'exécute dans ASP.NET SellHouse échouera dès que certaines des attentes seront terminées à l'intérieur. Cela se produit car vous avez essentiellement déclenché et oublié le contexte d'appel et de synchronisation a été perdu dès que FeedCat a échoué.

Voici l'erreur que vous obtiendrez pour le cas (3):

System.AggregateException: A Task's exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was rethrown by the finalizer thread. ---> System.NullReferenceException: Object reference not set to an instance of an object.
   at System.Web.ThreadContext.AssociateWithCurrentThread(Boolean setImpersonationContext)
   at System.Web.HttpApplication.OnThreadEnterPrivate(Boolean setImpersonationContext)
   at System.Web.HttpApplication.System.Web.Util.ISyncContext.Enter()
   at System.Web.Util.SynchronizationHelper.SafeWrapCallback(Action action)
   at System.Threading.Tasks.Task.Execute()
   --- End of inner exception stack trace ---
---> (Inner Exception #0) System.NullReferenceException: Object reference not set to an instance of an object.
   at System.Web.ThreadContext.AssociateWithCurrentThread(Boolean setImpersonationContext)
   at System.Web.HttpApplication.OnThreadEnterPrivate(Boolean setImpersonationContext)
   at System.Web.HttpApplication.System.Web.Util.ISyncContext.Enter()
   at System.Web.Util.SynchronizationHelper.SafeWrapCallback(Action action)
   at System.Threading.Tasks.Task.Execute()<---

Pour le cas (2), vous obtiendrez une erreur similaire mais avec une trace de pile d'exceptions d'origine.

Pour .NET 4.0 et versions ultérieures, vous pouvez intercepter les exceptions non observées à l'aide de TaskScheduler.UnobservedTaskException. Pour .NET 4.5 et les exceptions non observées ultérieures sont avalées par défaut pour .NET 4.0, l'exception non observée plantera votre processus.

Plus de détails ici: Gestion des exceptions de tâches dans .NET 4.5

Vous pouvez utiliser Task.WhenAllcomme mentionné, ou Task.WaitAll, selon que vous souhaitez que le thread attende. Jetez un œil au lien pour une explication des deux.

WaitAll vs WhenAll

Utilisez Task.WhenAllpuis attendez les résultats:

var tCat = FeedCat();
var tHouse = SellHouse();
var tCar = BuyCar();
await Task.WhenAll(tCat, tHouse, tCar);
Cat cat = await tCat;
House house = await tHouse;
Tesla car = await tCar; 
//as they have all definitely finished, you could also use Task.Value.

Avertissement avant

Juste un bref avertissement à ceux qui visitent ce sujet et d'autres threads similaires à la recherche d'un moyen de paralléliser EntityFramework en utilisant async + attendre + ensemble d'outils de tâche : le modèle montré ici est bon, cependant, quand il s'agit du flocon de neige spécial d'EF, vous ne le ferez pas réaliser une exécution parallèle à moins que et jusqu'à ce que vous utilisiez une (nouvelle) instance de contexte db distincte à l'intérieur de chaque appel * Async () impliqué.

Ce genre de chose est nécessaire en raison des limitations de conception inhérentes aux contextes ef-db qui interdisent d'exécuter plusieurs requêtes en parallèle dans la même instance de contexte ef-db.

En capitalisant sur les réponses déjà données, c'est le moyen de s'assurer que vous collectez toutes les valeurs même dans le cas où une ou plusieurs des tâches entraînent une exception:

  public async Task<string> Foobar() {
    async Task<string> Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) {
        return DoSomething(await a, await b, await c);
    }

    using (var carTask = BuyCarAsync())
    using (var catTask = FeedCatAsync())
    using (var houseTask = SellHouseAsync())
    {
        if (carTask.Status == TaskStatus.RanToCompletion //triple
            && catTask.Status == TaskStatus.RanToCompletion //cache
            && houseTask.Status == TaskStatus.RanToCompletion) { //hits
            return Task.FromResult(DoSomething(catTask.Result, carTask.Result, houseTask.Result)); //fast-track
        }

        cat = await catTask;
        car = await carTask;
        house = await houseTask;
        //or Task.AwaitAll(carTask, catTask, houseTask);
        //or await Task.WhenAll(carTask, catTask, houseTask);
        //it depends on how you like exception handling better

        return Awaited(catTask, carTask, houseTask);
   }
 }

Une implémentation alternative qui a plus ou moins les mêmes caractéristiques de performance pourrait être:

 public async Task<string> Foobar() {
    using (var carTask = BuyCarAsync())
    using (var catTask = FeedCatAsync())
    using (var houseTask = SellHouseAsync())
    {
        cat = catTask.Status == TaskStatus.RanToCompletion ? catTask.Result : (await catTask);
        car = carTask.Status == TaskStatus.RanToCompletion ? carTask.Result : (await carTask);
        house = houseTask.Status == TaskStatus.RanToCompletion ? houseTask.Result : (await houseTask);

        return DoSomething(cat, car, house);
     }
 }

var dn = await Task.WhenAll<dynamic>(FeedCat(),SellHouse(),BuyCar());

si vous souhaitez accéder à Cat, procédez comme suit:

var ct = (Cat)dn[0];

C'est très simple à faire et très utile à utiliser, il n'est pas nécessaire de rechercher une solution complexe.