Perché utilizzare async e attendere con l'attività <>?

Question

Se ho un metodo normale che voglio fare asincrona:

public int Foo(){} 

lo farei:

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

Perché dovrei fare:

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

Il modo ho intenzione di utilizzare questo è:

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

Voglio che il metodo sia eseguito senza fermarsi, ma voglio che venga attivato un callback, quindi lo ContinueWith. Ma con la seconda versione, c'è un punto per usarlo?

Answer 1

Nella mia comprensione, avete solo bisogno di async e await quando si scrive un metodo che fa un po 'di chiamate asincrone all'interno, ma si vorrebbe che sguardo come se non lo fa. In altre parole, si desidera scrivere e leggere il codice come se fosse un normale codice sequenziale, gestire le eccezioni come se fosse un normale codice sequenziale, restituire valori come se fosse un normale codice sequenziale e così via. Quindi la responsabilità del compilatore è di riscrivere quel codice con tutti i callback necessari preservando la logica.

Il tuo metodo è così semplice Non credo che sia necessario riscriverlo, puoi semplicemente restituire l'attività, ma chiunque la consuma potrebbe volere await per il suo valore di ritorno.

Answer 2

Perché dovrei fare:

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

Non lo faresti. La tua versione precedente restituisce Attività che è già in attesa. Questa nuova versione non aggiunge nulla.

Il modo ho intenzione di utilizzare questo è:

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

voglio il metodo di funzionare solo senza fermarsi, ma voglio qualcosa come un callback per essere licenziato, da cui il ContinueWith.

Questo è dove la differenza viene in Diamo rimpolpare il vostro esempio un po ':.

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

Utilizzando async, è possibile scrivere lo stesso codice come questo:

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

Il il risultato è lo stesso. La parola chiave await trasforma il resto del tuo metodo in una continuazione che viene ripresa dopo che FooAsync produce un valore. È proprio come il tuo altro codice, ma più facile da leggere. * shrug *