Warten auf mehrere Aufgaben mit unterschiedlichen Ergebnissen

Ich habe 3 Aufgaben:

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

Sie müssen alle ausgeführt werden, bevor mein Code fortgesetzt werden kann, und ich benötige auch die Ergebnisse von jedem. Keines der Ergebnisse hat etwas miteinander gemeinsam

Wie rufe ich an und warte, bis die 3 Aufgaben abgeschlossen sind, und erhalte dann die Ergebnisse?

Nach der Verwendung WhenAllkönnen Sie die Ergebnisse einzeln herausziehen mit 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;

Sie können auch verwenden Task.Result(da Sie zu diesem Zeitpunkt wissen, dass alle erfolgreich abgeschlossen wurden). Ich empfehle jedoch die Verwendung, awaitda dies eindeutig korrekt ist und Resultin anderen Szenarien Probleme verursachen kann.

Nur awaitdie drei Aufgaben getrennt, nachdem Sie alle gestartet haben.

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

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

Wenn Sie C # 7 verwenden, können Sie eine praktische Wrapper-Methode wie diese verwenden ...

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

... um eine bequeme Syntax wie diese zu aktivieren, wenn Sie auf mehrere Aufgaben mit unterschiedlichen Rückgabetypen warten möchten. Sie müssten natürlich mehrere Überladungen vornehmen, damit eine unterschiedliche Anzahl von Aufgaben auf Sie wartet.

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

In der Antwort von Marc Gravell finden Sie jedoch einige Optimierungen in Bezug auf ValueTask und bereits abgeschlossene Aufgaben, wenn Sie dieses Beispiel in etwas Reales verwandeln möchten.

Gegeben drei Aufgaben - FeedCat(), SellHouse()und BuyCar()gibt es zwei interessante Fälle: Entweder sie alle vollständig synchron (aus irgendeinem Grund, vielleicht das Caching oder ein Fehler), oder sie es nicht tun.

Nehmen wir an, wir haben aus der Frage:

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

Ein einfacher Ansatz wäre nun:

Task.WhenAll(x, y, z);

aber ... das ist nicht bequem für die Verarbeitung der Ergebnisse; Das möchten wir normalerweise 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);
}

Dies verursacht jedoch viel Overhead und weist verschiedene Arrays (einschließlich des params Task[]Arrays) und Listen (intern) zu. Es funktioniert, aber es ist nicht großartig, IMO. In vielerlei Hinsicht ist es einfacher , eine asyncOperation zu verwenden, und zwar awaitjeweils nacheinander:

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);
}

Im Gegensatz zu einigen der obigen Kommentare macht die Verwendung von awaitanstelle von keinen Unterschied für die Ausführung der Aufgaben (gleichzeitig, nacheinander usw.). Auf höchster Ebene vor einer guten Compiler-Unterstützung für / und war nützlich, wenn diese Dinge nicht existierten . Dies ist auch nützlich, wenn Sie eine beliebige Reihe von Aufgaben anstelle von drei diskreten Aufgaben haben.Task.WhenAllTask.WhenAll asyncawait

Aber: Wir haben immer noch das Problem, dass async/ awaitviel Compiler-Rauschen für die Fortsetzung erzeugt. Ist es wahrscheinlich , dass die Aufgaben ist vielleicht tatsächlich synchron abgeschlossen hat , dann können wir diese optimieren , indem sie mit einem asynchronen Rückfall in einem synchronen Pfad Aufbau:

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);
}

Dieser Ansatz "Synchronisierungspfad mit asynchronem Fallback" wird immer häufiger verwendet, insbesondere bei Hochleistungscode, bei dem synchrone Abschlüsse relativ häufig sind. Beachten Sie, dass es überhaupt nicht hilft, wenn die Fertigstellung immer wirklich asynchron ist.

Zusätzliche Dinge, die hier gelten:

1. Mit dem aktuellen C # wird ein allgemeines Muster für die asyncFallback-Methode verwendet, die üblicherweise als lokale Funktion implementiert wird:

   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. lieber ValueTask<T>, Task<T>wenn es eine gute Chance gibt, dass die Dinge jemals vollständig synchron mit vielen verschiedenen Rückgabewerten sind:

   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. wenn möglich, lieber IsCompletedSuccessfullyzu Status == TaskStatus.RanToCompletion; Dies gibt es jetzt in .NET Core für Taskund überall fürValueTask<T>

Sie können sie in Aufgaben speichern und dann auf alle warten:

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;

Wenn Sie versuchen, alle Fehler zu protokollieren, stellen Sie sicher, dass Sie die Zeile Task.WhenAll in Ihrem Code beibehalten. Viele Kommentare deuten darauf hin, dass Sie sie entfernen und auf einzelne Aufgaben warten können. Task.WhenAll ist wirklich wichtig für die Fehlerbehandlung. Ohne diese Zeile lassen Sie Ihren Code möglicherweise für unbeobachtete Ausnahmen offen.

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;

Stellen Sie sich vor, FeedCat löst eine Ausnahme im folgenden Code aus:

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

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

In diesem Fall werden Sie weder auf houseTask noch auf carTask warten. Hier gibt es 3 mögliche Szenarien:

1. SellHouse wurde bereits erfolgreich abgeschlossen, als FeedCat fehlschlug. In diesem Fall geht es dir gut.

2. SellHouse ist nicht vollständig und schlägt mit Ausnahme irgendwann fehl. Eine Ausnahme wird nicht beachtet und im Finalizer-Thread erneut ausgelöst.

3. SellHouse ist nicht vollständig und enthält Wartezeiten. Falls Ihr Code in ASP.NET ausgeführt wird, schlägt SellHouse fehl, sobald einige der darin enthaltenen Wartezeiten abgeschlossen sind. Dies geschieht, weil Sie im Grunde genommen einen Fire & Forget-Anruf getätigt haben und der Synchronisationskontext verloren gegangen ist, sobald FeedCat fehlgeschlagen ist.

Hier ist ein Fehler, den Sie für Fall (3) erhalten:

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()<---

In Fall (2) wird ein ähnlicher Fehler angezeigt, jedoch mit dem ursprünglichen Ausnahmestapel-Trace.

Für .NET 4.0 und höher können Sie nicht beobachtete Ausnahmen mit TaskScheduler.UnobservedTaskException abfangen. Für .NET 4.5 und höher werden nicht beobachtete Ausnahmen standardmäßig verschluckt. Für .NET 4.0 stürzt eine nicht beobachtete Ausnahme Ihren Prozess ab.

Weitere Details finden Sie hier: Behandlung von Aufgabenausnahmen in .NET 4.5

Sie können Task.WhenAllwie erwähnt oder verwenden Task.WaitAll, je nachdem, ob der Thread warten soll. Schauen Sie sich den Link an, um eine Erklärung für beide zu erhalten.

WaitAll vs WhenAll

Verwenden Sie Task.WhenAllund warten Sie dann auf die Ergebnisse:

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.

Vorwärtswarnung

Nur ein kurzer Überblick für diejenigen, die diesen und ähnliche Threads besuchen und nach einer Möglichkeit suchen, EntityFramework mithilfe des Tool-Sets async + await + task zu parallelisieren : Das hier gezeigte Muster ist solide, wenn es jedoch um die spezielle Schneeflocke von EF geht, werden Sie es nicht tun Erzielen Sie eine parallele Ausführung, es sei denn, Sie verwenden eine separate (neue) Datenbankkontextinstanz in jedem beteiligten * Async () -Aufruf.

Diese Art von Dingen ist aufgrund inhärenter Designbeschränkungen von ef-db-Kontexten erforderlich, die es verbieten, mehrere Abfragen parallel in derselben ef-db-Kontextinstanz auszuführen.

Wenn Sie die bereits gegebenen Antworten nutzen, können Sie auf diese Weise sicherstellen, dass Sie alle Werte erfassen, auch wenn eine oder mehrere der Aufgaben zu einer Ausnahme führen:

  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);
   }
 }

Eine alternative Implementierung mit mehr oder weniger denselben Leistungsmerkmalen könnte sein:

 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());

Wenn Sie auf Cat zugreifen möchten, gehen Sie folgendermaßen vor:

var ct = (Cat)dn[0];

Dies ist sehr einfach und sehr nützlich, es besteht keine Notwendigkeit, eine komplexe Lösung zu suchen.