¿Por qué utilizar async y esperar con Task <>?

Question

Si tengo un método normal que yo quiero hacer asíncrono:

public int Foo(){} 

que haría:

public Task<int> FooAsync(){ 
    return Task.Run(() => Foo()); 
} 

qué iba a hacer:

public async Task<int> FooAsync(){ 
    return await Task.Run(() => Foo()); 
} 

La forma en que planeo use esto es:

FooAsync().ContinueWith((res) => {}); 

Quiero que el método se ejecute sin parar, pero quiero que se active algo así como una devolución de llamada, de ahí el ContinueWith. Pero con la segunda versión, ¿hay algún punto para usarla?

Answer 1

En mi entendimiento, sólo es necesario async y await cuando se escribe un método que hace algunos asíncrono llama interior, pero que le gustaría que a mirada como si no lo hace. En otras palabras, desea escribir y leer el código como si fuera un código secuencial normal, manejar las excepciones como si fuera un código secuencial normal, devolver los valores como si fuera un código secuencial normal, y así sucesivamente. Entonces la responsabilidad del compilador es reescribir ese código con todas las devoluciones de llamada necesarias preservando la lógica.

Su método es tan simple que no creo que necesite esa reescritura en absoluto, solo puede devolver la tarea, pero quien la consuma puede querer await por su valor de retorno.

Answer 2

qué iba a hacer:

public async Task<int> FooAsync() 
{ 
    return await Task.Run(() => Foo()); 
} 

Usted no lo haría. Su versión anterior devuelve Tarea que ya está a la espera. Esta nueva versión no agrega nada.

La forma en que la intención de utilizar esto es:

FooAsync().ContinueWith((res) => {}); 

Quiero el método de sólo correr sin parar, pero quiero algo así como una devolución de llamada a ser despedido, por lo tanto el ContinueWith.

Esto es donde la diferencia viene en Vamos a dar cuerpo a su ejemplo, un poquito:.

void DoAsyncStuff() 
{ 
    FooAsync().ContinueWith((res) => { DoSomethingWithInt(res.Result) }); 
} 

Usando async, puede escribir el mismo código como este:

void async DoAsyncStuff() 
{ 
    int res = await FooAsync(); 
    DoSomethingWithInt(res); 
} 

El el resultado es el mismo La palabra clave await convierte el resto de su método en una continuación que se reanuda después de que FooAsync produzca un valor. Es como tu otro código, pero más fácil de leer. * shrug *