熟悉了c#的异步方法后，各种是不是就会有一种一发不可收拾的情况

对于我们熟悉的 async/await 方法，我们知道await可以执行一个异步方法，并且在方法结束后“继续”当前方法之后的代码。 这个对于执行耗时操作，且不阻塞当前线程的情形非常有效，例如

foo()
{
    await A_async();
    B();
}

那么假设下如果方法A_async会抛出异常，那怎么办。

很简单用trycatch,可以很好处理这些异常

foo()
{
    try
    {
        await A_async();
    }
    catch(Exception e)
    {
        Console.WriteLine(e);
    }
    B();
}

但是如果期望是在外部catch异常会如何？

foo()
{
    await A_async();
    B();
}

foo2()
{
    try
    {
        foo();
    }
    catch(Exception e)
    {
        Console.WriteLine(e);
    }
}

答案是无法catch。

虽然A_async()的异常是在foo方法内部抛出，但是在遇到await关键字时，foo2的线程就开始“分叉”成2个线程执行。所以可以认为，foo2的线程已经完成的他的try代码块

那么第二个问题，如果现在是方法B会抛出异常，而A_async不会，那么下面两种写法那种会被catch？

foo()
{
    await A_async().ConfigureAwaiter(True);
    B();
}

foo2()
{
    try
    {
        foo();
    }
    catch(Exception e)
    {
        Console.WriteLine(e);
    }
}

foo()
{
    await A_async().ConfigureAwaiter(False);
    B();
}

foo2()
{
    try
    {
        foo();
    }
    catch(Exception e)
    {
        Console.WriteLine(e);
    }
}

铛铛，都不会被catch。不管B是否在同步上下文执行，外层的catch代码都不会进行等待。

但是以下情况就会被catch咯

foo()
{
    B();
    await A_async().ConfigureAwaiter(False);
}

foo2()
{
    try
    {
        foo();
    }
    catch(Exception e)
    {
        Console.WriteLine(e);
    }
}

因为代码在遇到await 关键字之前，实际还在trycatch语句块之中。