Eine gute Lösung für warten in Versuch/Fang/endlich?

Question

Ich brauche eine async Methode in einem catch Block aufrufen, bevor wieder die Ausnahme zu werfen (mit seinem Stack-Trace) wie folgt aus:

try 
{ 
    // Do something 
} 
catch 
{ 
    // <- Clean things here with async methods 
    throw; 
} 

Aber leider kann man nicht await in einem catch oder finally Block verwenden. Ich habe gelernt, es ist, weil der Compiler keine Möglichkeit hat in einem catch Block zurück zu gehen auszuführen, was nach Ihrer await Anweisung oder so ähnlich ist ...

Ich versuchte Task.Wait() zu verwenden await zu ersetzen, und ich bekam eine Sackgasse. Ich habe im Internet gesucht, wie ich das vermeiden konnte und habe this site gefunden.

Da kann ich nicht die async Methoden ändern, noch weiß ich, ob sie ConfigureAwait(false) verwenden, ich diese Methoden erstellt, die ein Func<Task> nehmen, die ein asynchrones Verfahren beginnt, wenn wir auf einem anderen Thread (zu vermeiden, dass ein Deadlock) und wartet sind für seine Vollendung:

public static void AwaitTaskSync(Func<Task> action) 
{ 
    Task.Run(async() => await action().ConfigureAwait(false)).Wait(); 
} 

public static TResult AwaitTaskSync<TResult>(Func<Task<TResult>> action) 
{ 
    return Task.Run(async() => await action().ConfigureAwait(false)).Result; 
} 

public static void AwaitSync(Func<IAsyncAction> action) 
{ 
    AwaitTaskSync(() => action().AsTask()); 
} 

public static TResult AwaitSync<TResult>(Func<IAsyncOperation<TResult>> action) 
{ 
    return AwaitTaskSync(() => action().AsTask()); 
} 

So ist meine Fragen: glauben Sie, dieser Code in Ordnung ist?

Natürlich, wenn Sie einige Verbesserungen haben oder einen besseren Ansatz kennen, höre ich! :)

Answer 1

Sie können die Logik außerhalb des Blocks catch verschieben und die Ausnahme nach Bedarf erneut auslösen, indem Sie ExceptionDispatchInfo verwenden.

static async Task f() 
{ 
    ExceptionDispatchInfo capturedException = null; 
    try 
    { 
     await TaskThatFails(); 
    } 
    catch (MyException ex) 
    { 
     capturedException = ExceptionDispatchInfo.Capture(ex); 
    } 

    if (capturedException != null) 
    { 
     await ExceptionHandler(); 

     capturedException.Throw(); 
    } 
} 

Auf diese Weise, wenn der Anrufer die StackTrace Eigenschaft Ausnahme prüft, wo es noch Aufzeichnungen innerhalb TaskThatFails wurde geworfen.

public static class TryWithAwaitInCatch 
{ 
    public static async Task ExecuteAndHandleErrorAsync(Func<Task> actionAsync, 
     Func<Exception, Task<bool>> errorHandlerAsync) 
    { 
     ExceptionDispatchInfo capturedException = null; 
     try 
     { 
      await actionAsync().ConfigureAwait(false); 
     } 
     catch (Exception ex) 
     { 
      capturedException = ExceptionDispatchInfo.Capture(ex); 
     } 

     if (capturedException != null) 
     { 
      bool needsThrow = await errorHandlerAsync(capturedException.SourceException).ConfigureAwait(false); 
      if (needsThrow) 
      { 
       capturedException.Throw(); 
      } 
     } 
    } 
} 

Man würde es verwenden, wie folgt:

Answer 2

Wenn Sie async Fehlerbehandlungsroutinen verwenden müssen, würde ich so etwas wie dies empfehlen:

Exception exception = null; 
try 
{ 
    ... 
} 
catch (Exception ex) 
{ 
    exception = ex; 
} 

if (exception != null) 
{ 
    ... 
} 

Das Problem mit synchron Blockierung auf async Code (unabhängig davon, was Gewinde auf es läuft) ist, dass Sie synchron blockieren. In den meisten Fällen ist es besser, await zu verwenden.

Aktualisierung: Da Sie erneut starten müssen, können Sie ExceptionDispatchInfo verwenden.

Answer 3

Wir hvd's great answer auf die folgende wiederverwendbare Utility-Klasse in unserem Projekt extrahiert

public async Task OnDoSomething() 
    { 
     await TryWithAwaitInCatch.ExecuteAndHandleErrorAsync(
      async() => await DoSomethingAsync(), 
      async (ex) => { await ShowMessageAsync("Error: " + ex.Message); return false; } 
     ); 
    } 

Fühlen Sie sich frei, um die Namensgebung zu verbessern, hielten wir es absichtlich ausführliche . Beachten Sie, dass der Kontext im Wrapper nicht erfasst werden muss, da er bereits in der Aufruf-Site erfasst ist, daher ConfigureAwait(false).

Answer 4

Sie sollten das seit C# 6 wissen.0, dann ist es möglich, await in catch und finally Blöcke zu verwenden, so könnte man dies in der Tat:

try 
{ 
    // Do something 
} 
catch (Exception ex) 
{ 
    await DoCleanupAsync(); 
    throw; 
} 

Die neuen C# 6.0-Funktionen, einschließlich der, die ich gerade erwähnt are listed here oder als Video here.