未处理的异步异常

Question

Reasons for avoiding async void aside, is it possible to catch the following error from calling code?

private static Action ErrorAction
{
  get
  {
    return async () =>
    {
      await Task.Delay(0);
      throw new NotImplementedException();
    };
  }
}

For example in both of the following I'd like to collect the exceptions thrown, but both tests fail:

[Test]
public void SelfContainedExampleTryCatch()
{
  List<Exception> errors = new List<Exception>();
  try
  {
     ErrorAction();
  }
  catch (Exception ex)
  {
    errors.Add(ex);
  }
  errors.Count().Should().Be(1);
}

[Test]
public void SelfContainedExampleContinueWith()
{
  List<Exception> errors = new List<Exception>();
  var task = Task.Factory.StartNew(ErrorAction);
  task.ContinueWith(t =>
                {
                    errors.Add(t.Exception);
                }, TaskContinuationOptions.OnlyOnFaulted);
  task.Wait();

  errors.Count().Should().Be(1);
}

I know I could use a method with an async Task signature; but specifically it's the Action assignable delegate async code sample I'm needing to handle, and catching at a global level isn't practicable. If it's possible, a solution common for both sync and async Actions would be ideal.

Hopefully there's a simple solution I've missed, but so far I've only headed down numerous dead ends and have (perhaps incorrectly) concluded it's not possible. Any help (or time-wasting saved) would be appreciated!

Answer 1

There are some cases where a framework requires you to use async void when sometimes you'd really rather not (eg, ICommand.Execute ). In these cases, I generally recommend introducing an await -compatible API and just make your async void methods very simple wrappers:

static Func<Task> ErrorActionAsync
{
  get
  {
    return async () =>
    {
      await Task.Yield();
      throw new NotImplementedException();
    };
  }
}

private static Action ErrorAction
{
  get
  {
    return async () => { await ErrorActionAsync(); }
  }
}

(on a side note, I changed await Task.Delay(0) to await Task.Yield() since await Task.Delay(0) is a noop).

Then you can use ErrorActionAsync rather than ErrorAction in your unit tests. This approach does mean you'll have small amounts of untested code (the async void wrapper - ErrorAction ).

However, if you want to keep ErrorAction as-is, and it can be synchronous or asynchronous, then there is another possibility. I have written an AsyncContext type that you can use like this:

[Test]
public void SelfContainedExampleTryCatch()
{
  List<Exception> errors = new List<Exception>();
  try
  {
    AsyncContext.Run(() => ErrorAction());
  }
  catch (Exception ex)
  {
    errors.Add(ex);
  }
  errors.Count().Should().Be(1);
}

AsyncContext.Run will block until the async void method completes, and will capture exceptions from async void methods and raise them directly.

Answer 2

If you want ErrorAction to be able to cater for asynchronous calls and then still be able to handle exceptions at the call site, then I think you will just have to bite the bullet and change the ErrorAction to return Task .

If you do decide to change the contract, it will probably be a good idea to maintain the synchronous nature of your existing non-async implmentations. You can do this by:

private static Task ErrorAction
{
  get
  {
    // Synchronous code here

    return Task.FromResult(true);
  }
}

Answer 3

I think returning Task is possible without changing the contract. See this example:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;

namespace ConsoleApplication1
    {
    class Program
        {
        static void Main(string[] args)
            {
            SelfContainedExampleTryCatch();
            SelfContainedExampleContinueWith();
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
            }

        public static void SelfContainedExampleTryCatch()
            {
            var errors = new List<Exception>();
            try
                {
                ErrorAction();
                }
            catch (Exception ex)
                {
                errors.Add(ex);
                }
            errors.Count().Should().Be(1);
            }

        public static void SelfContainedExampleContinueWith()
            {
            var errors = new List<Exception>();
            var task = Task.Factory.StartNew(ErrorAction);
            task.ContinueWith(t =>
            {
                errors.Add(t.Exception);
            }, TaskContinuationOptions.OnlyOnFaulted);
            task.Wait();

            errors.Count().Should().Be(1);
            }

        private static Action ErrorAction
            {
            get
                {
                return () => DoTask().Wait();
                }
            }

        private static async Task DoTask() {
            await Task.Delay(0);
            throw new NotImplementedException();
            }
        }
    }

The ContinueWith test passes, but the other test won't. Which I believe is your intention.