¿Cuál es el propósito de "retorno espera" en C #?

¿Hay algún escenario en el que escribir un método como este:

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

en lugar de esto:

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

tendría sentido?

¿Por qué usar return awaitconstruct cuando puedes regresar directamente Task<T>de la DoAnotherThingAsync()invocación interna ?

Veo código return awaiten tantos lugares, creo que podría haber perdido algo. Pero por lo que entiendo, no usar palabras clave asíncronas / esperar en este caso y devolver directamente la Tarea sería funcionalmente equivalente. ¿Por qué agregar sobrecarga adicional de awaitcapa adicional ?

Hay un caso disimulado cuando returnen el método normal y return awaiten asynccomportan método diferente: cuando se combina con using(o, más en general, cualquier return awaiten un trybloque).

Considere estas dos versiones de un método:

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

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

El primer método será Dispose()el Fooobjeto tan pronto como el DoAnotherThingAsync()método regrese, lo que probablemente sea mucho antes de que realmente se complete. Esto significa que la primera versión probablemente tenga errores (porque Foose desecha demasiado pronto), mientras que la segunda versión funcionará bien.

Si no lo necesita async(es decir, puede devolverlo Taskdirectamente), no lo use async.

Hay algunas situaciones en las que return awaites útil, como si tiene dos operaciones asincrónicas que hacer:

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

Para obtener más información sobre el asyncrendimiento, consulte el artículo y el video de MSDN de Stephen Toub sobre el tema.

Actualización: he escrito una publicación de blog que entra en mucho más detalle.

La única razón por la que querría hacerlo es si hay algún otro awaiten el código anterior, o si de alguna manera está manipulando el resultado antes de devolverlo. Otra forma en que eso podría estar sucediendo es a través de un try/catchcambio en la forma en que se manejan las excepciones. Si no está haciendo nada de eso, tiene razón, no hay razón para agregar la sobrecarga de hacer el método async.

Otro caso que puede necesitar para esperar el resultado es este:

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

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

En este caso, GetIFooAsync()debe esperar el resultado de GetFooAsyncporque el tipo de Tes diferente entre los dos métodos y Task<Foo>no se puede asignar directamente Task<IFoo>. Pero si espera el resultado, se convierte en lo Fooque es directamente asignable IFoo. Luego, el método asíncrono simplemente vuelve a empaquetar el resultado dentro Task<IFoo>y fuera de donde vaya.

Hacer asincrónico el método "thunk" de otra manera simple crea una máquina de estado asincrónica en la memoria, mientras que la no asincrónica no. Si bien eso a menudo puede apuntar a la gente a usar la versión no asíncrona porque es más eficiente (lo cual es cierto), también significa que en el caso de un bloqueo, no tienes evidencia de que ese método esté involucrado en la "pila de retorno / continuación" lo que a veces hace que sea más difícil entender el bloqueo.

Entonces, sí, cuando el rendimiento no es crítico (y generalmente no lo es), lanzaré asíncrono en todos estos métodos de thunk para que tenga la máquina de estado asíncrona que me ayude a diagnosticar bloqueos más tarde, y también para ayudar a garantizar que si esos Los métodos thunk siempre evolucionan con el tiempo, se asegurarán de devolver las tareas fallidas en lugar de tirar.

Si no va a utilizar return aguarda, puede arruinar el seguimiento de la pila durante la depuración o cuando se imprime en los registros de excepciones.

Cuando devuelve la tarea, el método cumplió su propósito y está fuera de la pila de llamadas. Cuando lo usa, return awaitlo está dejando en la pila de llamadas.

Por ejemplo:

Pila de llamadas cuando se usa esperar: A esperando la tarea de B => B esperando la tarea de C

Pila de llamadas cuando no se usa esperar: A esperando la tarea de C, que B ha devuelto.

Esto también me confunde y siento que las respuestas anteriores pasaron por alto su pregunta real:

¿Por qué usar return waitit construct cuando puede devolver directamente Task desde la invocación interna DoAnotherThingAsync ()?

Bueno, a veces realmente quieres un Task<SomeType>, pero la mayoría de las veces realmente quieres una instancia SomeType, es decir, el resultado de la tarea.

De tu código:

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

Una persona que no Task<SomeResult>esté familiarizada con la sintaxis (yo, por ejemplo) podría pensar que este método debería devolver a , pero como está marcado con async, significa que su tipo de retorno real es SomeResult. Si solo usa return foo.DoAnotherThingAsync(), estaría devolviendo una Tarea, que no se compilaría. La forma correcta es devolver el resultado de la tarea, por lo que el return await.