Eccezioni gestite non gestite da asincrono

Question

Quando un metodo async atteso genera un'eccezione, l'eccezione viene memorizzata da qualche parte e il lancio viene ritardato. In un'applicazione WinForms o WPF, utilizza SynchronizationContext.Current per pubblicare l'eccezione. Tuttavia, ad es. un'applicazione console, lancia l'eccezione su un pool di thread e fa scendere l'applicazione.

Come impedire che le eccezioni generate da un metodo async provochino il rilascio dell'applicazione?

EDIT:

Appearantly il problema che sto descrivendo è perché ho voidasync metodi. Vedi i commenti.

Answer 1

Quando viene avviato il metodo async, acquisisce il contesto di sincronizzazione corrente. Un modo per risolvere questo problema è creare il proprio contesto di sincronizzazione che cattura l'eccezione.

Il punto qui è che il contesto messaggi di sincronizzazione della richiamata al pool di thread, ma con un try/catch intorno ad esso:

public class AsyncSynchronizationContext : SynchronizationContext 
{ 
    public override void Send(SendOrPostCallback d, object state) 
    { 
     try 
     { 
      d(state); 
     } 
     catch (Exception ex) 
     { 
      // Put your exception handling logic here. 

      Console.WriteLine(ex.Message); 
     } 
    } 

    public override void Post(SendOrPostCallback d, object state) 
    { 
     try 
     { 
      d(state); 
     } 
     catch (Exception ex) 
     { 
      // Put your exception handling logic here. 

      Console.WriteLine(ex.Message); 
     } 
    } 
} 

Nella catch sopra di voi può mettere la logica di gestione delle eccezioni.

Avanti, su ogni filo (SynchronizationContext.Current è [ThreadStatic]) in cui si desidera eseguire async metodi con questo meccanismo, è necessario impostare il contesto di sincronizzazione corrente:

SynchronizationContext.SetSynchronizationContext(new AsyncSynchronizationContext()); 

La completa Main esempio:

class Program 
{ 
    static void Main(string[] args) 
    { 
     SynchronizationContext.SetSynchronizationContext(new AsyncSynchronizationContext()); 

     ExecuteAsyncMethod(); 

     Console.ReadKey(); 
    } 

    private static async void ExecuteAsyncMethod() 
    { 
     await AsyncMethod(); 
    } 

    private static async Task AsyncMethod() 
    { 
     throw new Exception("Exception from async"); 
    } 
} 

Answer 2

Come è possibile impedire che le eccezioni generate da un metodo asincrono causino il ribasso dell'applicazione?

Seguire queste procedure:

1. Tutti async metodi dovrebbero tornare Task o Task<T> a meno che non abbiano per tornare void (ad esempio, i gestori di eventi).
2. A un certo punto, è necessario await tutti i Task s restituiti dai metodi async. L'unica ragione per cui non vorresti farlo è se non ti interessa più il risultato dell'operazione (ad es. Dopo averlo annullato).
3. Se è necessario rilevare un'eccezione da un gestore di eventi async void, rilevarlo nel gestore eventi, esattamente come si farebbe se si trattasse di codice sincrono.

È possibile trovare il mio async/await intro post utile; Copro anche molte altre buone pratiche.