Was ist der Zweck von "Rückkehr warten" in C #?

Gibt es ein Szenario, in dem eine solche Schreibmethode angewendet wird:

public async Task<SomeResult> DoSomethingAsync()
{
    // Some synchronous code might or might not be here... //
    return await DoAnotherThingAsync();
}

an Stelle von:

public Task<SomeResult> DoSomethingAsync()
{
    // Some synchronous code might or might not be here... //
    return DoAnotherThingAsync();
}

würde Sinn machen?

Warum return awaitKonstrukt verwenden, wenn Sie direkt Task<T>vom inneren DoAnotherThingAsync()Aufruf zurückkehren können?

Ich sehe Code mit return awaitan so vielen Stellen, dass ich glaube, ich hätte etwas verpasst. Soweit ich weiß, wäre es jedoch funktional gleichwertig, in diesem Fall keine asynchronen / wartenden Schlüsselwörter zu verwenden und die Aufgabe direkt zurückzugeben. Warum zusätzlichen Aufwand für zusätzliche awaitEbene hinzufügen ?

Es gibt einen Fall , wenn sneaky returnin normalen Verfahren und return awaitin asyncVerfahren , verhalten sich anders: in Kombination mit using(oder, allgemeiner, jeder return awaitin einem tryBlock).

Betrachten Sie diese beiden Versionen einer Methode:

Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return foo.DoAnotherThingAsync();
    }
}

async Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return await foo.DoAnotherThingAsync();
    }
}

Bei der ersten Methode wird Dispose()das FooObjekt ausgeführt, sobald die DoAnotherThingAsync()Methode zurückgegeben wird. Dies ist wahrscheinlich lange bevor sie tatsächlich abgeschlossen ist. Dies bedeutet, dass die erste Version wahrscheinlich fehlerhaft ist (weil Foosie zu früh entsorgt wird), während die zweite Version einwandfrei funktioniert.

Wenn Sie nicht benötigen async(dh Sie können die Taskdirekt zurückgeben), dann verwenden Sie nicht async.

Es gibt Situationen, in denen dies return awaitnützlich ist, z. B. wenn Sie zwei asynchrone Vorgänge ausführen müssen:

var intermediate = await FirstAsync();
return await SecondAwait(intermediate);

Weitere Informationen zur asyncLeistung finden Sie im MSDN-Artikel und im Video von Stephen Toub zum Thema.

Update: Ich habe einen Blog-Beitrag geschrieben , der viel detaillierter ist.

Der einzige Grund, warum Sie dies tun möchten, ist, wenn awaitder frühere Code einen anderen enthält oder wenn Sie das Ergebnis auf irgendeine Weise manipulieren, bevor Sie es zurückgeben. Eine andere Möglichkeit besteht darin, die try/catchBehandlung von Ausnahmen zu ändern. Wenn Sie nichts davon tun, haben Sie Recht, es gibt keinen Grund, den Aufwand für die Erstellung der Methode zu erhöhen async.

Ein weiterer Fall, den Sie möglicherweise benötigen, um auf das Ergebnis zu warten, ist der folgende:

async Task<IFoo> GetIFooAsync()
{
    return await GetFooAsync();
}

async Task<Foo> GetFooAsync()
{
    var foo = await CreateFooAsync();
    await foo.InitializeAsync();
    return foo;
}

In diesem Fall GetIFooAsync()muss das Ergebnis abwarten, GetFooAsyncda der Typ von Tzwischen den beiden Methoden unterschiedlich ist und Task<Foo>nicht direkt zugeordnet werden kann Task<IFoo>. Aber wenn Sie das Ergebnis warten, wird es nur , Foodas ist direkt zuordenbar IFoo. Dann packt die asynchrone Methode das Ergebnis einfach neu Task<IFoo>und los.

Wenn Sie die ansonsten einfache "Thunk" -Methode asynchronisieren, wird eine asynchrone Zustandsmaschine im Speicher erstellt, während die nicht asynchrone dies nicht tut. Während dies oft darauf hindeutet, dass die nicht asynchrone Version verwendet wird, weil sie effizienter ist (was wahr ist), bedeutet dies auch, dass Sie im Falle eines Hangs keine Beweise dafür haben, dass diese Methode am "Rückgabe- / Fortsetzungsstapel" beteiligt ist. was es manchmal schwieriger macht, den Hang zu verstehen.

Also ja, wenn perf nicht kritisch ist (und normalerweise auch nicht), werde ich all diese Thunk-Methoden asynchronisieren, damit ich die asynchrone Zustandsmaschine habe, die mir hilft, Hänge später zu diagnostizieren und um sicherzustellen, dass dies der Fall ist Wenn sich Thunk-Methoden im Laufe der Zeit weiterentwickeln, werden sie sicher fehlerhafte Aufgaben zurückgeben, anstatt sie zu werfen.

Wenn Sie return wait nicht verwenden, können Sie Ihren Stack-Trace beim Debuggen oder beim Drucken in den Protokollen bei Ausnahmen ruinieren.

Wenn Sie die Aufgabe zurückgeben, hat die Methode ihren Zweck erfüllt und befindet sich außerhalb des Aufrufstapels. Wenn Sie verwenden return await, belassen Sie es im Aufrufstapel.

Beispielsweise:

Aufrufstapel bei Verwendung von Warten: A wartet auf die Aufgabe von B => B wartet auf die Aufgabe von C.

Aufrufliste , wenn nicht unter Verwendung Await: A Warten auf die Aufgabe von C, die B zurückgekehrt ist.

Das verwirrt mich auch und ich habe das Gefühl, dass die vorherigen Antworten Ihre eigentliche Frage übersehen haben:

Warum das Konstrukt return await verwenden, wenn Sie Task direkt vom inneren DoAnotherThingAsync () -Aufruf zurückgeben können?

Nun, manchmal möchten Sie tatsächlich eine Task<SomeType>, aber meistens möchten Sie tatsächlich eine Instanz SomeType, dh das Ergebnis der Aufgabe.

Aus Ihrem Code:

async Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return await foo.DoAnotherThingAsync();
    }
}

Eine Person, die mit der Syntax nicht vertraut ist (ich zum Beispiel), könnte denken, dass diese Methode a zurückgeben sollte Task<SomeResult>, aber da sie mit markiert ist async, bedeutet dies, dass ihr tatsächlicher Rückgabetyp ist SomeResult. Wenn Sie nur verwenden return foo.DoAnotherThingAsync(), geben Sie eine Aufgabe zurück, die nicht kompiliert werden kann. Der richtige Weg ist, das Ergebnis der Aufgabe zurückzugeben, also die return await.