Effetti dell'utilizzo di più attese nello stesso metodo?

Question

Ho il seguente metodo che impegna le modifiche a un db (utilizzando Entity Framework):

public async Task<int> CommitAsync(Info info) 
{ 
    if (this.Database.Connection.State == ConnectionState.Closed) 
     await this.Database.Connection.OpenAsync(); 

    await SetInfo(info); 
    return await base.SaveChangesAsync(); 
} 

è sicuro da usare come è il metodo di cui sopra, o dovrei:

1. Evitare di utilizzare async-await, o
2. Usa ContinueWith

Answer 1

e 'assolutamente bene avere più await espres ssioni nello stesso metodo async - altrimenti sarebbe una funzione relativamente inutile.

Fondamentalmente, il metodo verrà eseguito in modo sincrono finché non raggiunge il primo await dove l'attendibile coinvolto non è ancora stato completato. Verrà quindi restituito al chiamante, dopo aver impostato una continuazione per l'attendibile per eseguire il resto del metodo asincrono. Se l'esecuzione successiva raggiunge un altro await espressione dove l'awaitable non ha già completato, una continuazione è impostato su che awaitable, ecc

Ogni volta che il metodo "riprende" da un attendono, essa esercita in cui era stata spento, con le stesse variabili locali ecc. Ciò è ottenuto dal compilatore che costruisce una macchina di stato per conto dell'utente.

Answer 2

Il tuo codice sembra perfetto. Dà al tuo interlocutore l'opportunità di fare qualcosa di utile nei momenti che stai aspettando, invece di fare un'attesa impegnativa finché tutto è finito.

La cosa bella di usare async-await invece di usare ContinueWith è che il tuo codice sembra abbastanza sincrono. È facile vedere in quale ordine verranno eseguite le dichiarazioni. Continua Con consente inoltre di specificare l'ordine, ma è un po 'più difficile da vedere.

Se un thread entra in una procedura asincrona esegue la procedura fino a quando non soddisfa un'attesa. Invece di aspettare fino a quando la procedura attesa è finita, il controllo viene restituito al chiamante che può continuare a eseguire le istruzioni successive fino a quando non incontra un'attesa, dove viene dato il controllo al chiamante ecc. Una volta che tutti sono in attesa e il tuo OpenAsync è finito il thread continua a fare le dichiarazioni dopo OpenAsync fino a quando non incontra un'altra attesa.

Qualcuno qui in StackOverflow (ahimè ha perso il suo nome) mi ha spiegato una volta che il processo async-await in un breakfast metaphor.

Un'introduzione molto utile, Stephen Cleary about Async-await. Ti rendiamo conto anche di come async-await previene i problemi con InvokeRequired