324

使用 Microsoft for .NET 的异步 CTP，是否可以在调用方法中捕获异步方法引发的异常？

public async void Foo()
{
    var x = await DoSomethingAsync();

    /* Handle the result, but sometimes an exception might be thrown.
       For example, DoSomethingAsync gets data from the network
       and the data is invalid... a ProtocolException might be thrown. */
}

public void DoFoo()
{
    try
    {
        Foo();
    }
    catch (ProtocolException ex)
    {
          /* The exception will never be caught.
             Instead when in debug mode, VS2010 will warn and continue.
             The deployed the app will simply crash. */
    }
}

所以基本上我希望异步代码中的异常能够冒泡到我的调用代码中，如果这可能的话。

4

6 回答 6

303

读起来有点奇怪，但是是的，异常会冒泡到调用代码——但前提是你await或Wait()调用Foo.

public async Task Foo()
{
    var x = await DoSomethingAsync();
}

public async void DoFoo()
{
    try
    {
        await Foo();
    }
    catch (ProtocolException ex)
    {
          // The exception will be caught because you've awaited
          // the call in an async method.
    }
}

//or//

public void DoFoo()
{
    try
    {
        Foo().Wait();
    }
    catch (ProtocolException ex)
    {
          /* The exception will be caught because you've
             waited for the completion of the call. */
    }
}

正如 Stephen Cleary 在Async/Await - 异步编程最佳实践中所写：

Async void 方法具有不同的错误处理语义。当异步任务或异步任务方法抛出异常时，会捕获该异常并将其放置在任务对象上。对于 async void 方法，没有 Task 对象，因此从 async void 方法抛出的任何异常都将直接在 async void 方法启动时处于活动状态的 SynchronizationContext 上引发。

请注意Wait()，如果 .NET 决定同步执行您的方法，则 using 可能会导致您的应用程序阻塞。

这个解释http://www.interact-sw.co.uk/iangblog/2010/11/01/csharp5-async-exceptions非常好 - 它讨论了编译器为实现这一魔法所采取的步骤。

于 2011-03-21T20:42:21.470 回答
80

未捕获异常的原因是 Foo() 方法具有 void 返回类型，因此当调用 await 时，它只是返回。由于 DoFoo() 不等待 Foo 的完成，因此无法使用异常处理程序。

如果您可以更改方法签名，这将打开一个更简单的解决方案 - alterFoo()使其返回 typeTask然后DoFoo()can await Foo()，如以下代码所示：

public async Task Foo() {
    var x = await DoSomethingThatThrows();
}

public async void DoFoo() {
    try {
        await Foo();
    } catch (ProtocolException ex) {
        // This will catch exceptions from DoSomethingThatThrows
    }
}
于 2013-04-22T23:25:20.950 回答
20

你的代码没有做你认为它做的事情。异步方法在方法开始等待异步结果后立即返回。使用跟踪来调查代码的实际行为是很有见地的。

下面的代码执行以下操作：

  • 创建 4 个任务
  • 每个任务将异步增加一个数字并返回增加的数字
  • 当异步结果到达时，它会被跟踪。

 

static TypeHashes _type = new TypeHashes(typeof(Program));        
private void Run()
{
    TracerConfig.Reset("debugoutput");

    using (Tracer t = new Tracer(_type, "Run"))
    {
        for (int i = 0; i < 4; i++)
        {
            DoSomeThingAsync(i);
        }
    }
    Application.Run();  // Start window message pump to prevent termination
}


private async void DoSomeThingAsync(int i)
{
    using (Tracer t = new Tracer(_type, "DoSomeThingAsync"))
    {
        t.Info("Hi in DoSomething {0}",i);
        try
        {
            int result = await Calculate(i);
            t.Info("Got async result: {0}", result);
        }
        catch (ArgumentException ex)
        {
            t.Error("Got argument exception: {0}", ex);
        }
    }
}

Task<int> Calculate(int i)
{
    var t = new Task<int>(() =>
    {
        using (Tracer t2 = new Tracer(_type, "Calculate"))
        {
            if( i % 2 == 0 )
                throw new ArgumentException(String.Format("Even argument {0}", i));
            return i++;
        }
    });
    t.Start();
    return t;
}

当你观察痕迹

22:25:12.649  02172/02820 {          AsyncTest.Program.Run 
22:25:12.656  02172/02820 {          AsyncTest.Program.DoSomeThingAsync     
22:25:12.657  02172/02820 Information AsyncTest.Program.DoSomeThingAsync Hi in DoSomething 0    
22:25:12.658  02172/05220 {          AsyncTest.Program.Calculate    
22:25:12.659  02172/02820 {          AsyncTest.Program.DoSomeThingAsync     
22:25:12.659  02172/02820 Information AsyncTest.Program.DoSomeThingAsync Hi in DoSomething 1    
22:25:12.660  02172/02756 {          AsyncTest.Program.Calculate    
22:25:12.662  02172/02820 {          AsyncTest.Program.DoSomeThingAsync     
22:25:12.662  02172/02820 Information AsyncTest.Program.DoSomeThingAsync Hi in DoSomething 2    
22:25:12.662  02172/02820 {          AsyncTest.Program.DoSomeThingAsync     
22:25:12.662  02172/02820 Information AsyncTest.Program.DoSomeThingAsync Hi in DoSomething 3    
22:25:12.664  02172/02756          } AsyncTest.Program.Calculate Duration 4ms   
22:25:12.666  02172/02820          } AsyncTest.Program.Run Duration 17ms  ---- Run has completed. The async methods are now scheduled on different threads. 
22:25:12.667  02172/02756 Information AsyncTest.Program.DoSomeThingAsync Got async result: 1    
22:25:12.667  02172/02756          } AsyncTest.Program.DoSomeThingAsync Duration 8ms    
22:25:12.667  02172/02756 {          AsyncTest.Program.Calculate    
22:25:12.665  02172/05220 Exception   AsyncTest.Program.Calculate Exception thrown: System.ArgumentException: Even argument 0   
   at AsyncTest.Program.c__DisplayClassf.Calculateb__e() in C:\Source\AsyncTest\AsyncTest\Program.cs:line 124   
   at System.Threading.Tasks.Task`1.InvokeFuture(Object futureAsObj)    
   at System.Threading.Tasks.Task.InnerInvoke()     
   at System.Threading.Tasks.Task.Execute()     
22:25:12.668  02172/02756 Exception   AsyncTest.Program.Calculate Exception thrown: System.ArgumentException: Even argument 2   
   at AsyncTest.Program.c__DisplayClassf.Calculateb__e() in C:\Source\AsyncTest\AsyncTest\Program.cs:line 124   
   at System.Threading.Tasks.Task`1.InvokeFuture(Object futureAsObj)    
   at System.Threading.Tasks.Task.InnerInvoke()     
   at System.Threading.Tasks.Task.Execute()     
22:25:12.724  02172/05220          } AsyncTest.Program.Calculate Duration 66ms      
22:25:12.724  02172/02756          } AsyncTest.Program.Calculate Duration 57ms      
22:25:12.725  02172/05220 Error       AsyncTest.Program.DoSomeThingAsync Got argument exception: System.ArgumentException: Even argument 0  

Server stack trace:     
   at AsyncTest.Program.c__DisplayClassf.Calculateb__e() in C:\Source\AsyncTest\AsyncTest\Program.cs:line 124   
   at System.Threading.Tasks.Task`1.InvokeFuture(Object futureAsObj)    
   at System.Threading.Tasks.Task.InnerInvoke()     
   at System.Threading.Tasks.Task.Execute()     

Exception rethrown at [0]:      
   at System.Runtime.CompilerServices.TaskAwaiter.EndAwait()    
   at System.Runtime.CompilerServices.TaskAwaiter`1.EndAwait()  
   at AsyncTest.Program.DoSomeThingAsyncd__8.MoveNext() in C:\Source\AsyncTest\AsyncTest\Program.cs:line 106    
22:25:12.725  02172/02756 Error       AsyncTest.Program.DoSomeThingAsync Got argument exception: System.ArgumentException: Even argument 2  

Server stack trace:     
   at AsyncTest.Program.c__DisplayClassf.Calculateb__e() in C:\Source\AsyncTest\AsyncTest\Program.cs:line 124   
   at System.Threading.Tasks.Task`1.InvokeFuture(Object futureAsObj)    
   at System.Threading.Tasks.Task.InnerInvoke()     
   at System.Threading.Tasks.Task.Execute()     

Exception rethrown at [0]:      
   at System.Runtime.CompilerServices.TaskAwaiter.EndAwait()    
   at System.Runtime.CompilerServices.TaskAwaiter`1.EndAwait()  
   at AsyncTest.Program.DoSomeThingAsyncd__8.MoveNext() in C:\Source\AsyncTest\AsyncTest\Program.cs:line 0      
22:25:12.726  02172/05220          } AsyncTest.Program.DoSomeThingAsync Duration 70ms   
22:25:12.726  02172/02756          } AsyncTest.Program.DoSomeThingAsync Duration 64ms   
22:25:12.726  02172/05220 {          AsyncTest.Program.Calculate    
22:25:12.726  02172/05220          } AsyncTest.Program.Calculate Duration 0ms   
22:25:12.726  02172/05220 Information AsyncTest.Program.DoSomeThingAsync Got async result: 3    
22:25:12.726  02172/05220          } AsyncTest.Program.DoSomeThingAsync Duration 64ms

您会注意到 Run 方法在线程 2820 上完成，而只有一个子线程完成 (2756)。如果您在 await 方法周围放置一个 try/catch，您可以以通常的方式“捕获”异常，尽管您的代码在计算任务完成并执行 contiuation 时在另一个线程上执行。

计算方法会自动跟踪抛出的异常，因为我确实使用了ApiChange工具中的 ApiChange.Api.dll。Tracing and Reflector 有助于理解发生了什么。要摆脱线程，您可以创建自己的 GetAwaiter BeginAwait 和 EndAwait 版本，并在您自己的扩展方法中包装不是任务而是例如 Lazy 和跟踪。然后，您将更好地理解编译器和 TPL 的作用。

现在您看到没有办法尝试/捕获您的异常，因为没有堆栈帧可供任何异常传播。在您启动异步操作后，您的代码可能会做一些完全不同的事情。它可能会调用 Thread.Sleep 甚至终止。只要剩下一个前台线程，您的应用程序就会愉快地继续执行异步任务。

在异步操作完成并回调 UI 线程后，您可以在 async 方法中处理异常。推荐的方法是使用TaskScheduler.FromSynchronizationContext。这只有在你有一个 UI 线程并且它不是很忙于其他事情时才有效。

于 2011-03-21T21:49:18.397 回答
5

同样重要的是要注意，如果您在异步方法上有 void 返回类型，您将丢失异常的时间堆栈跟踪。我建议按如下方式返回任务。将使调试变得容易得多。

public async Task DoFoo()
    {
        try
        {
            return await Foo();
        }
        catch (ProtocolException ex)
        {
            /* Exception with chronological stack trace */     
        }
    }
于 2014-07-04T12:17:12.133 回答
4

异常可以在异步函数中捕获。

public async void Foo()
{
    try
    {
        var x = await DoSomethingAsync();
        /* Handle the result, but sometimes an exception might be thrown
           For example, DoSomethingAsync get's data from the network
           and the data is invalid... a ProtocolException might be thrown */
    }
    catch (ProtocolException ex)
    {
          /* The exception will be caught here */
    }
}

public void DoFoo()
{
    Foo();
}
于 2011-03-21T20:50:02.453 回答
3

这个博客巧妙地解释了你的问题Async Best Practices。

它的要点是你不应该使用 void 作为异步方法的返回，除非它是一个异步事件处理程序，这是不好的做法，因为它不允许捕获异常;-)。

最佳实践是将返回类型更改为 Task。此外，尝试一直编写异步代码，进行每个异步方法调用并从异步方法中调用。除了控制台中的 Main 方法，它不能是异步的（在 C# 7.1 之前）。

如果您忽略此最佳实践，您将遇到 GUI 和 ASP.NET 应用程序的死锁。发生死锁是因为这些应用程序在只允许一个线程并且不会将其交给异步线程的上下文中运行。这意味着 GUI 同步等待返回，而异步方法等待上下文：死锁。

此行为不会在控制台应用程序中发生，因为它在带有线程池的上下文中运行。async 方法将在另一个将被调度的线程上返回。这就是为什么测试控制台应用程序可以工作，但相同的调用会在其他应用程序中死锁......

于 2017-11-09T09:37:03.867 回答