TPL e gestione delle eccezioni

Question

Tutti, ci sono molte domande sull'argomento sopra, ma credo che questo sia sufficientemente diverso da giustificare una nuova domanda. Ho il seguente Task e una continuazione per gestire una varietà di attività Status; TaskStatus.RanToCompletion, TaskStatus.Canceled e, naturalmente, lo via TaskStatus.Faulted. Il codice è simile

Task<bool> asyncTask = Task.Factory.StartNew<bool>(() => 
    asyncMethod(uiScheduler, token, someBoolean), token); 

asyncTask.ContinueWith(task => 
{ 
    // Check task status. 
    switch (task.Status) 
    { 
     // Handle any exceptions to prevent UnobservedTaskException.    
     case TaskStatus.RanToCompletion: 
      if (asyncTask.Result) 
      { 
       // Do stuff... 
      } 
      break; 
     case TaskStatus.Faulted: 
      if (task.Exception != null) 
       mainForm.progressRightLabelText = task.Exception.InnerException.Message; 
      else 
       mainForm.progressRightLabelText = "Operation failed!"; 
     default: 
      break; 
    } 
} 

Questo tutto funziona bene, ma sono preoccupato anche se non sto facendo questo diritto, in quanto v'è la possibilità di un AggregateException gettati dentro la continuazione - che cosa allora?

Io non voglio Wait sul mio asyncTask né la continuazione in quanto ciò bloccherà il ritorno al thread UI. Per intercettare eventuali eccezioni generate dall'interno di una continuazione non può significare che devo fare una cosa del genere sicuramente

Task parentTask = Task.Factory.startNew(() => 
    { 
     Task<bool> asyncTask = Task.Factory.StartNew<bool>(() => 
      asyncMethod(uiScheduler, token, someBoolean), token); 

     Task continueTask = asyncTask.ContinueWith(task => 
      { 
       // My continuation stuff... 
      } 

     try 
     { 
      continueTask.Wait(); 
     } 
     catch(AggregateException aggEx) 
     { 
      // Some handling here... 
     } 
    }); 

Sarebbe questo anche il lavoro? Qual è la migliore pratica qui?

Come sempre, grazie per il vostro tempo.

Answer 1

È possibile usare tradizionale try/catch all'interno dei vostri delegati guardare per AggregateException oppure è possibile concatenare in continuazioni specifici che sempre e solo eseguito se l'antecedente è in errore utilizzando l'opzione TaskContinuationOptions.OnlyOnFaulted. Quest'ultimo approccio consente di definire flussi di lavoro delle attività molto puliti. Ad esempio:

Task myRootTask = ....; 

myRootTask.ContinueWith(rootAntecdent => 
{ 
    // this will only be executed if the antecedent completed successfully, no need to check for faults 
}, 
TaskContinuationOptions.OnlyOnRanToCompletion); 

myRootTask.ContinueWith(rootAntecedent => 
{ 
    // this will only be executed if the antecedent faulted, observe exception and handle accordingly 
}, 
TaskContinuationOptions.OnlyOnFaulted); 

Answer 2

Msdn ha un abbastanza ben scritto "Come" sul tema: here

Si noterà che utilizzano semplicemente a) blocco try/catch(AggregateException, poi filtrare l'eccezione che sanno come gestire in ae.Handle(lambda) e rendere la fermata app se ce ne sono alcuni che non sono maneggiabili.