五、处理异步操作中的异常

本示例学习如何在异步函数中处理异常，学习如何对多个并行的异步操作使用await时聚合异常。

1.程序示例代码如下。

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

namespace ThreadAsyncDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(string.Format("-----    处理异步操作中的异常----"));
            Task t = AsyncProcess();
            t.Wait();       

            Console.Read();         

        } 

        async static Task AsyncProcess()
        {
            Console.WriteLine(string.Format("-----    1   单个异常处理----"));
            try
            {
               string result =await GetInfoAsync("Task 1", 2);
                Console.WriteLine(result);
            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("异常信息：{0}",ex.Message));
            }

            Console.WriteLine(string.Format("                   -------   ----"));
            Console.WriteLine(string.Format("-----    2   多个异常处理----"));
            Task<string> task1 = GetInfoAsync("Task 1", 3);
            Task<string> task2 = GetInfoAsync("Task 2",2);
            try
            {
                string[] results = await Task.WhenAll(task1, task2);
                Console.WriteLine((string.Format("结果数量：{0}",results.Length)));
                foreach (var item in results)
                {
                    Console.WriteLine(item);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("异常信息：{0}", ex.Message));
            }           

            Console.WriteLine(string.Format("                   -------   ----"));
            Console.WriteLine(string.Format("-----    3   多个异常处理 在AggregateException----"));
            Task<string> task3 = GetInfoAsync("Task 3", 3);
            Task<string> task4 = GetInfoAsync("Task 4", 2);
            Task<string[]> task5 = Task.WhenAll(task3, task4);
            try
            {
                string[] results5 = await task5;
                Console.WriteLine((string.Format("结果数量：{0}", results5.Length)));
                foreach (var item in results5)
                {
                    Console.WriteLine(item);
                }
            }
            catch
            {
                var aex = task5.Exception.Flatten(); //获取AggregateException
                var exs = aex.InnerExceptions;
                Console.WriteLine(string.Format("异常信息：{0}", exs.Count));
                int i = 0;
                foreach (var item in exs)
                {
                    i++;
                    Console.WriteLine(string.Format("       -----   {0}   ----",i));
                    Console.WriteLine(string.Format("异常信息：{0}", item.Message));
                }
            }
        } 

        async static Task<string> GetInfoAsync(string name,int second)
        {
            Console.WriteLine(string.Format(" Task {0} 正在运行在线程 ID={1}上。这个工作线程是否是线程池中的线程：{2}", name, 
Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread));
            await Task.Delay(TimeSpan.FromSeconds(second));
            throw new Exception(string.Format("{0} 抛出异常信息！", name));

        }
    }
}

2.程序运行结果，如下图。

这个程序一共有三个场景来学习使用async与await时，关于异常处理的常见情况。

第一种情况最简单，与常见的同步代码几乎一样，我们只使用try catch即可获取异常信息。

第二种情况是对一个以上的异步异常使用await时，则只能从aggregateexception对象中得到第一个异常。

第三种情况中，我们使用aggregateException中的flatten方法将层级异常放入一个列表，并从中提取所有的底层异常。

六、避免使用捕获的同步上下文

本示例学习使用await来获取异步操作结果时，同步上下文行为的结节，并如何在何时关闭同步上下文流。

默认情况下，await操作符会尝试捕获同步上下文，并在其中执行代码。使用await操作符不会发生死锁的情况，因为当等待结果时并不会阻塞UI线程。

在解决方案管理器中右键—>添加引用。。。，如下图。

2.在“引用管理器”中找到System.Windows.Forms引用，并添加。如下图。

3. 添加一个windows窗体。如下图。

4. 在windows窗体中，添加按钮与文本框，界面如下图。

6 .代码如下图。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms; 

namespace ThreadAsyncDemo
{
    public partial class FormContext : Form
    {
        public FormContext()
        {
            InitializeComponent();
        } 

        async static Task<TimeSpan> TestNoContext()
        {
            const int interationsNumber = 100000;
            var sw = new Stopwatch();
            sw.Start();
            for (int i = 0; i < interationsNumber; i++)
            {
                var t = Task.Run(() => { });
                await t.ConfigureAwait(continueOnCapturedContext: false);
            }

            sw.Stop();
            return sw.Elapsed;
        }
        async static Task<TimeSpan> Test()
        {
            const int interationsNumber = 100000;
            var sw = new Stopwatch();
            sw.Start();
            for (int i = 0; i < interationsNumber; i++)
            {
                var t = Task.Run(() => { });
                await t;
            }
            sw.Stop();
            return sw.Elapsed; 

        } 

        private async void buttonAsync_Click(object sender, EventArgs e)
        {
            textBoxMsg.Text = "程序开始计算。。。。";
            TimeSpan resultWithContext = await Test();
            TimeSpan resultNoContext = await TestNoContext();
            //TimeSpan resultNoContext = await TestNoContext().ConfigureAwait(false);
            var sb = new StringBuilder();
            sb.AppendLine(string.Format("有上下文的运行时间：{0}",resultWithContext));
            sb.AppendLine(string.Format("没有上下文的运行时间：{0}", resultNoContext));
            sb.AppendLine(string.Format("有上下文的运行时间/没有上下文的运行时间：{0:0.00}", 
resultWithContext.TotalMilliseconds/ resultNoContext.TotalMilliseconds));
            textBoxMsg.Text += "\r\n\r\n";
            textBoxMsg.Text += sb.ToString();
        }
    }
}

7.程序运行结果，如下图。

这是一个windowform程序，我们在winfowform程序中创建了一个按钮点击事件，当点击这个按钮时，运行两个异步操作，其中一个异步操作使用了await操作符，别一个使用了带false参数值的configureAwait方法。False参数明确指出我们不能对其使用捕获的同步上下文来运行后续的代码。在每个操作中，我们计算了执行完成花费的时间，然后将各自的时间比较显示在屏幕上。

从中我们发现await操作符花费了更多的时间来完成。这是因为我们向UI线程中放入了上千的后续操作任务，这就造成了使用消息循环来异步执行这些任务。而带有false参数值的configureAwait方法是一个更高效的解决方式。

我们还可以进行以下操作，当程序运行之后，在点击按钮后，等待结果时，可以随机拖拽应用程序窗口从一侧到另一侧，此时你注意一下，会发现捕获同步上下文的代码执行速度变慢了。如下图。

最后，我们来看看相反的情况。在代码的点击事件中，取消注释行，并注释掉紧挨着它的前一行代码。运行程序，我们将看到多线程控制访问的异常。因为设置Label文本的代码没有放到捕捉的上下文中的，而是在线程池的工作线程中执行。如下图。

posted @ 2017-12-27 10:16 DotNet菜园阅读(1978) 评论(1) 编辑收藏举报

刷新页面返回顶部

DotNet菜园

专注所以专业,专业所以专注

多线程编程学习笔记——async和await（三）

公告