第八章介绍了 C# 中可用异步编程的实践和解决方案，还讨论了何时适合使用异步编程等。本章主要介绍 async 和 await 关键字。

        其实在之前的学习中，大家都已经了解过这两个关键字了，用得非常多。其实我觉得没有必要再赘述了，不过这里还是简单地看一看吧。

        本教程学习工程：魔术师Dix / HandsOnParallelProgramming · GitCode

        因为篇幅限制，本篇为下篇，主要内容为异步代码的异常处理和使用异步代码的一些注意事项。

---

3、异步代码的异常处理

        在使用同步代码的情况下，所有异常都将传播到堆栈顶部，直到它们被 try-catch 块处理或作为未处理的异常抛出为止。

        在使用异步方法时，调用堆栈是不一样的，因为线程先是从方法转换到线程池，然后又回到了线程池。

        接下来将通过示例来了解程序异常的表现：

        public static async Task ExceptionFunction()
        {
            Debug.Log($"开始执行异常方法！");
            await Task.Delay(1500);
            int x = 5;
            Debug.Log($"准备抛出异常！");
            Debug.Log(x / 0);
        }

        这里我们写一个错误方法，最后应该会出错，这里我们直接使用 Task.Run 来运行：

Task.Run(ExceptionFunction);

        结果显而易见，不会有异常的打印，代码直接在错误的地方中断了，而没有下文：

         使用 Thread 来调用上述代码也是一样的，不会抛出异常。

3.1、在 try-catch 外部创建任务

        示例代码如下：

        private void RunWithExceptionFuntion()
        {
            Task task = Task.Run(ExceptionFunction);
            try
            {
                task.ContinueWith(x =>
                {
                    Debug.Log(x.IsFaulted);
                });
            }
            catch (Exception ex)
            {
                Debug.LogError(ex.InnerException);//这样不会抛出异常
            }
        }

        这么写不会有异常抛出：

         try-catch 里没有对此错误有任何感知，就像从来没有发生过一样。 

3.2、在 try-catch 内部创建任务

        现在我们修改一下代码，在将 Task 的创建移动到 try-catch 内部：

        private void RunWithExceptionFuntion()
        {
            try
            {
                Task task = Task.Run(TestFunction.ExceptionFunction);
                task.ContinueWith(x =>
                {
                    Debug.Log(x.IsFaulted);
                });
            }
            catch (Exception ex)
            {
                Debug.LogError(ex.InnerException);
            }
        }

        与书上不一样的是，这样依然没有任何有异常抛出，执行结果和 3.1 一样。在第二章的时候已经说过这个问题了，需要将 Task 调回主线程（Task.Wait），才能正常执行报错。

3.3、用子线程收集子线程的异常

        但是直接调用 Task.Wait 会导致调用线程卡死，如果是主线程调用就会导致主线程卡死以等待异步。显然我们也不想调用线程等待，不然异步就没意义了。

        所以解决方案是：当我们需要启动子线程（Task B）时，先启动一个线程（Task A）来运行 Task B；之后 Task A等待 Task B 完成，以收集错误：
 

        private void RunWithExceptionFuntion()
        {
            RunExceptionFuntionAsync();
        }

        private async void RunExceptionFuntionAsync()
        {
            try
            {
                Task task = Task.Run(TestFunction.ExceptionFunction);
                await task;
                Debug.Log(task.IsFaulted);
            }
            catch (Exception ex)
            {
                Debug.LogError("出错了！");
                Debug.LogError(ex.Message);
            }
        }

简单写法就如上所示，这样就能正常打印出错误了。

3.4、返回 void 会导致程序崩溃？

        在书中提到这么一个案例：

        private void RunWithCrashFunction()
        {
            Task task = TestFunction.ExceptionFunction();
            Debug.Log($"RunWithCrashFunction End {task}");
        }

        如果上述代码返回的是 void 而不是 Task，则会导致程序崩溃。但实际上这个问题并不存在，在我的版本中根本过不了编译：

         这个语法在 ExceptionFunction ，返回值无论是 void 还是 Task 都不会报错，但是在调用时还是严格区分了 void 和 Task 的。所以即便返回值错误，IDE 也会自动帮我们检测出来。

        书上可能是老版本的 C# 了，现在的版本并不存在这种情况。

4、使用 PLINQ 实现异步

        其实使用 PLINQ 在 第四章：使用PLINQ 里已经详细讲解过了，这里就不赘述了。书上这一章节也没有讲什么新东西，可以跳过。

5、衡量异步代码的性能

        这里这本书先讲了一个示例：

        private async void RunWithWaitDebugAll()
        {
            int x = await Utils.WaitWithTask(1100);
            int y = await Utils.WaitWithTask(2100);
            int z = await Utils.WaitWithTask(1500);
            Debug.Log($"返回结果：{x + y + z}");
        }

        像这样的代码，虽然不会阻塞主线程，但是是串行的，任务是完成等待另一个依次执行。书上建议做如下行改造，将三个任务并行：

        private async void RunWithWaitDebugAll()
        {
            int[] ret = await Task.WhenAll(Utils.WaitWithTask(1000), Utils.WaitWithTask(1500), Utils.WaitWithTask(412));
            int sum = 0;
            foreach (var item in ret)
                sum += item;
            Debug.Log($"返回结果：{sum}");
        }

        个运行效果非常明显，同样是不会阻塞主线程，但是等待时间不是 3 个Task 之和，而是其中的最大值。显然在不少使用场景中，这样的写法是有优势的。当然，如果在业务上，确实需要串行以保证逻辑，还是可以使用第一种写法。

        简单地说，就是小任务尽量异步同时派发，用其他方法（例如信号灯、事件）来保证逻辑时序。

6、使用异步代码的准则

        这一章其实并不是我们想象中的一些干货、法则之类的，主要讲了以下事项：

        避免使用异步 void ：在前面的章节看到了返回 void 的一些弊端，比如不能等待，或者无任务状态返回等。所以基本上能返回 Task 就返回 Task，这个其实也没什么好说的。

        在 ASP.NET 中会有一些死锁的问题：

Task.ConfigureAwait 方法 (System.Threading.Tasks) | Microsoft Learn配置用于等待此 Task的 awaiter。 https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.configureawait?view=netstandard-2.1

        但是在 Unity 中使用 Task.Wait 并不会有这些问题。

---

7、本章小结

        本章感觉偏水……

        无非就是讨论了 async 和 await 两个关键字，然后在提出了 void 和 Task 的返回值之类的问题。但实际上这些问题在之前的章节学习中就已经涉及过了，还写了不少代码测试……

        最后还有就是说，尽量避免写需要切换任务上下文的代码，能并行就并行。当然这个还是根据业务需求来，并在实际工作中实践就好。

         本教程学习工程：魔术师Dix / HandsOnParallelProgramming · GitCode