Come posso produrre un task <Task> a scartare

Question

Qualcuno può spiegare la differenza tra queste due affermazioni:

Task<Task> bTask = backup.BackupCurrentDatabaseAsync() 
    .ContinueWith(_ => CompressArchiveAsync()); 
//unwrap the tasks to produce one entire task 
Task t = bTask.Unwrap(); 

vs

Task<Task> bTask = backup.BackupCurrentDatabaseAsync() 
    .ContinueWith(_ => 
{ 
    CompressArchiveAsync(); 
}); 
//unwrap the tasks to produce one entire task 
Task t = bTask.Unwrap(); 

I metodi ExtractArchiveAsync(), BackupCurrentDatabaseAsync(), RestoreDatabaseAsync() tutto restituiscono un Task.

Qui, il primo Continuazione restituisce un Task<Task>. Posso quindi eseguire l'attività Unwrap() per continuare con l'attività risultante (interna).

La seconda versione non viene compilata. L'unica differenza qui sono le parentesi graffe attorno allo CompressArchiveAsync().

Sto tentando di accedere al risultante (interno) Task per controllare lo Task.Status. Se utilizzo il secondo metodo, Task.Status sta segnalando il risultato dell'attività BackupCurrentDatabaseAsync().

Answer 1

.ContinueWith(_ => CompressArchiveAsync()); 

è equivalente a:

.ContinueWith(_ => 
{ 
    return CompressArchiveAsync(); 
}); 

Avviso del return.

Il codice secondo frammento di non viene compilato perché ContinueWith non restituisce un Task<Task>, ma semplicemente un Task, e non c'è niente da scartare.

Di seguito è legata ad una Func<Task, Task> (una funzione che prende un Task e restituisce un Task)

_ => 
{ 
    return CompressArchiveAsync(); 
} 

Ma il seguente è in realtà associato a un Action<Task> (una funzione che prende un Task, ma non lo fa restituire nulla):

_ => 
{ 
    CompressArchiveAsync(); 
} 

E il riferimento al Task creato da CompressArchiveAsync non è mai tornato. Senza un riferimento ad esso, non è possibile controllare lo stato di Task.

Nota che:

• ContinueWith<TResult>(Func<Task, TResult>) restituisce un Task<TResult>
• ContinueWith(Action<Task>) restituisce un Task.

quindi il vostro ContinueWith(Func<Task, Task>) restituisce un Task<Task> che si può scartare, ma il vostro ContinueWith(Action<Task>) restituisce semplicemente un Task.

Answer 2

La differenza è nella sintassi Lambda Expression.

Ci sono 2 tipi di Lambda: Espressione lambda e Dichiarazione lambda. Expression Lambdas non ha parentesi e restituisce il risultato dell'espressione mentre Statement Lambdas ha parentesi contenenti zero o più istruzioni (una di esse può essere una dichiarazione return).

Quindi questa espressione lambda:

_ => CompressArchiveAsync() 

è equivalente a questa Normativa Lambda:

_ => { return CompressArchiveAsync(); } 

Quindi, la differenza è che nel primo prosecuzione si restituisce un compito, ma nel secondo si no, è solo un vuoto delegato anonimo. Ecco perché la prima continuazione è una Task<Task> mentre la seconda è solo una Task.

Answer 3

Nel primo esempio, si chiama ContinueWith con un Func. Pertanto, restituirà un Task<T>. Il secondo tentativo chiamerà il sovraccarico ContinueWith con un Action, perché ... beh è un'azione, non restituisce nulla. Quindi restituirà un semplice Task senza T.

Answer 4

Commento lungo per mostrare il codice 4.5.

Se si potesse passare a .Net 4.5 di codice che si sta tentando di scrivere può essere riscritta in modo più compatto con async/await che è essenzialmente implementa tutto ciò che il codice interno:

async Task CompleteBackup() 
{ 
    await backup.BackupCurrentDatabaseAsync() 
    await CompressArchiveAsync()); 
    await ..... 
}