Differenza tra await e ContinueWith

Qualcuno può spiegare se awaite ContinueWithsono sinonimi o meno nel seguente esempio. Sto cercando di utilizzare TPL per la prima volta e ho letto tutta la documentazione, ma non capisco la differenza.

Aspetta :

String webText = await getWebPage(uri);
await parseData(webText);

Continua con :

Task<String> webText = new Task<String>(() => getWebPage(uri));
Task continue = webText.ContinueWith((task) =>  parseData(task.Result));
webText.Start();
continue.Wait();

Uno è preferito rispetto all'altro in situazioni particolari?

Nel secondo codice, stai aspettando in modo sincrono il completamento della continuazione. Nella prima versione, il metodo tornerà al chiamante non appena raggiunge la prima awaitespressione che non è già stata completata.

Sono molto simili in quanto entrambi programmano una continuazione, ma non appena il flusso di controllo diventa anche leggermente complesso, awaitporta a un codice molto più semplice. Inoltre, come notato da Servy nei commenti, l'attesa di un'attività "scarterà" le eccezioni aggregate che di solito portano a una gestione più semplice degli errori. Anche l'utilizzo awaitpianificherà implicitamente la continuazione nel contesto chiamante (a meno che non venga utilizzato ConfigureAwait). Non è niente che non possa essere fatto "manualmente", ma è molto più facile farlo await.

Ti suggerisco di provare a implementare una sequenza di operazioni leggermente più ampia con entrambi awaite Task.ContinueWith- può aprire gli occhi.

Ecco la sequenza di frammenti di codice che ho usato di recente per illustrare la differenza e vari problemi utilizzando le soluzioni asincrone.

Supponi di avere un gestore di eventi nella tua applicazione basata su GUI che richiede molto tempo e quindi desideri renderlo asincrono. Ecco la logica sincrona con cui inizi:

while (true) {
    string result = LoadNextItem().Result;
    if (result.Contains("target")) {
        Counter.Value = result.Length;
        break;
    }
}

LoadNextItem restituisce un'attività, che alla fine produrrà alcuni risultati che desideri esaminare. Se il risultato corrente è quello che stai cercando, aggiorni il valore di un contatore sull'interfaccia utente e torni dal metodo. In caso contrario, continui a elaborare più elementi da LoadNextItem.

Prima idea per la versione asincrona: usa solo le continuazioni! E ignoriamo la parte in loop per il momento. Voglio dire, cosa potrebbe andare storto?

return LoadNextItem().ContinueWith(t => {
    string result = t.Result;
    if (result.Contains("target")) {
        Counter.Value = result.Length;
    }
});

Ottimo, ora abbiamo un metodo che non blocca! Invece si blocca. Eventuali aggiornamenti ai controlli dell'interfaccia utente dovrebbero essere eseguiti nel thread dell'interfaccia utente, quindi sarà necessario tenerne conto. Per fortuna, c'è un'opzione per specificare come dovrebbero essere pianificate le continuazioni, e ce n'è una predefinita solo per questo:

return LoadNextItem().ContinueWith(t => {
    string result = t.Result;
    if (result.Contains("target")) {
        Counter.Value = result.Length;
    }
},
TaskScheduler.FromCurrentSynchronizationContext());

Ottimo, ora abbiamo un metodo che non si blocca! Invece fallisce silenziosamente. Le continuazioni sono esse stesse attività separate, con il loro stato non legato a quello dell'attività antecedente. Quindi, anche se LoadNextItem ha un errore, il chiamante vedrà solo un'attività che è stata completata con successo. Ok, quindi trasmetti l'eccezione, se ce n'è una:

return LoadNextItem().ContinueWith(t => {
    if (t.Exception != null) {
        throw t.Exception.InnerException;
    }
    string result = t.Result;
    if (result.Contains("target")) {
        Counter.Value = result.Length;
    }
},
TaskScheduler.FromCurrentSynchronizationContext());

Fantastico, ora funziona davvero. Per un singolo articolo. Ora, che ne dici di quel loop. Si scopre che una soluzione equivalente alla logica della versione sincrona originale sarà simile a questa:

Task AsyncLoop() {
    return AsyncLoopTask().ContinueWith(t =>
        Counter.Value = t.Result,
        TaskScheduler.FromCurrentSynchronizationContext());
}
Task<int> AsyncLoopTask() {
    var tcs = new TaskCompletionSource<int>();
    DoIteration(tcs);
    return tcs.Task;
}
void DoIteration(TaskCompletionSource<int> tcs) {
    LoadNextItem().ContinueWith(t => {
        if (t.Exception != null) {
            tcs.TrySetException(t.Exception.InnerException);
        } else if (t.Result.Contains("target")) {
            tcs.TrySetResult(t.Result.Length);
        } else {
            DoIteration(tcs);
        }});
}

Oppure, invece di tutto quanto sopra, puoi usare async per fare la stessa cosa:

async Task AsyncLoop() {
    while (true) {
        string result = await LoadNextItem();
        if (result.Contains("target")) {
            Counter.Value = result.Length;
            break;
        }
    }
}

Adesso è molto più carino, no?