C#异步编程一

前几天把Code First系列总结完，想着下步总结什么，原本想着XML,不过XML的内容比较多,还有3天班就中秋节了，想在中秋节前在完成一个系列，所以决定把异步这块总结下。说起异步可能会认为就是多线程，其实并不是这样，多线程之一解决异步的一种方式，单线程也可以实现异步。C#中异步主要包括异步委托和异步任务。今天总结下异步委托。

一、同步问题

大家小时候都可能听说过小明上学的故事，小明起床要洗脸、烧水、做饭、跑步、吃饭，今天来的例子也还是小明，不过不是上学而是睡觉。小明睡觉之前要洗澡洗干净了。

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

namespace AsyncDemo
{
    public class Heater
    {
        /// <summary>
        /// 设定的温度
        /// </summary>
        public int SetTemp { get; set; }

        /// <summary>
        /// 当前水温
        /// </summary>
        private int _currentTemp;
        public int CurrentTemp
        {
            get { return _currentTemp; }
        }

        private bool _flag;
        public bool Flag
        {
            get { return _flag; }

        }

        public Heater()
        {
            this._flag = false;
        }

        /// <summary>
        /// 烧水
        /// </summary>
        public int BoilWater()
        {

            for (int i = ; i <= ; i++)
            {
                Thread.Sleep();
                _currentTemp = i;
                Console.WriteLine("当前温度{0}",_currentTemp);
                if (_currentTemp >= SetTemp)
                {
                    _flag = true;
                    break;
                }
            }
            return _currentTemp;
        }
    }
}

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

namespace AsyncDemo
{
    public class XiaoMing
    {
        public Heater heater { get; set; }

        public XiaoMing(Heater heater)
        {
            this.heater = heater;
        }

        public int OpenHeater()
        {
            Console.WriteLine("打开热水器,开始烧水");
            return heater.BoilWater();
        }

        public void WatchTv()
        {
            Console.WriteLine("看电视中");
        }
    }
}

        static void Main(string[] args)
        {
            Heater heater = new Heater();
            heater.SetTemp = ;
            XiaoMing xiaoMing = new XiaoMing(heater);
            xiaoMing.OpenHeater();
            xiaoMing.WatchTv();
            if (xiaoMing.heater.Flag)
            {
                Console.WriteLine("水烧好了");
            }
            Console.ReadLine();
        }

小明想着烧着水闲着也是闲着，不能开着热水器吧，他想看电视，看片。但是看下面的输入让小明失望了。

小明傻眼了，我这要看着烧水器的温度，烧好了，才能看电视，这不行啊，还要上床呢。看电视只是在烧水的时候看会。这要是在烧水的时候我能看会电视多好。

二、异步的引入

上面也看到了，烧水和看电视不能同时进行，那怎么能同时进行，烧水又不是小明烧，是热水器烧，自己只是打开热水器就好了。为了解决这个问题,C#中有了异步委托。

首先引用MSDN中的一段话来描述一下如何使用异步方式
.NET Framework 允许您异步调用任何方法。 为此，应定义与您要调用的方法具有相同签名的委托；公共语言运行时会自动使用适当的签名为该委托定义 BeginInvoke 和 EndInvoke 方法。

BeginInvoke 方法启动异步调用。 该方法与您需要异步执行的方法具有相同的参数，还有另外两个可选参数。 第一个参数是一个 AsyncCallback 委托，该委托引用在异步调用完成时要调用的方法。 第二个参数是一个用户定义的对象，该对象将信息传递到回调方法。 BeginInvoke 立即返回，不等待异步调用完成。 BeginInvoke 返回一个 IAsyncResult，后者可用于监视异步调用的进度。

EndInvoke 方法检索异步调用的结果。 在调用 BeginInvoke 之后随时可以调用该方法。 如果异步调用尚未完成，则 EndInvoke 会一直阻止调用线程，直到异步调用完成。 EndInvoke 的参数包括您需要异步执行的方法的 out 和 ref 参数（在 Visual Basic 中为 <Out> ByRef 和 ByRef）以及由 BeginInvoke 返回的 IAsyncResult。

如果上面的定义认真多读几遍，基本把异步委托精髓学到了。下面就在上面的代码基础上改变一下，让小明可以在烧水的时候可以看电视。

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

namespace AsyncDemo
{
    public class XiaoMing
    {
        public Heater heater { get; set; }

        //应定义与您要调用的方法具有相同签名的委托
        public delegate int BoilWaterDelegate(int orgTemp);

        private BoilWaterDelegate _BoilWaterDelegate { get; set; }

        public XiaoMing(Heater heater)
        {
            this.heater = heater;
            _BoilWaterDelegate = new BoilWaterDelegate(heater.BoilWater);
        }

        /// <summary>
        /// BeginInvoke 立即返回，不等待异步调用完成。 BeginInvoke 返回一个 IAsyncResult，后者可用于监视异步调用的进度。
        /// </summary>
        /// <param name="orgTemp"></param>
        /// <param name="callBack"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public IAsyncResult BeginBoilWater(int orgTemp,AsyncCallback callBack, object obj)
        {
            Console.WriteLine("打开热水器,开始烧水");
            try
            {
                //BeginInvoke 函数中 回调函数前面的参数是给委托传的参数 后面是给回调函数传的参数
                // 该方法与需要异步执行的方法具有相同的参数,还有另外两个可选参数,orgTemp与需要异步执行的方法具有相同的参数
                //第一个参数是一个 AsyncCallback 委托，该委托引用在异步调用完成时要调用的方法 callBack就是
                //第二个参数是一个用户定义的对象，该对象将信息传递到回调方法 obj就是
                return _BoilWaterDelegate.BeginInvoke(orgTemp, callBack, obj);
            }
            catch (Exception ex)
            {

                throw ex;
            }
        }

        /// <summary>
        /// 烧水结束
        /// </summary>
        /// <param name="ar"></param>
        /// <returns></returns>
        public int EndBoilWater(IAsyncResult ar)
        {
            if (ar == null)
                throw new NullReferenceException("IAsyncResult 参数不能为空");
            try
            {
                return _BoilWaterDelegate.EndInvoke(ar);
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public void WatchTv()
        {
            Console.WriteLine("看电视中");
        }

        public void Wash(IAsyncResult ir)
        {
            string someThing= ir.AsyncState as string;
            Console.WriteLine("拿{0}洗澡",someThing);
        }

        public void Sleep()
        {
            Console.WriteLine("上床睡觉");
        }
    }
}

为了运行上面的定义，在委托上加了一个参数设置一个起始温度，并设置了回调函数。并在回调函数Wash中使用了自定义的一个对象。注意上面的注释前面的BeginInvoke 的描述，它们是对应着的。

        static void Main(string[] args)
        {
            Heater heater = new Heater();
            heater.SetTemp = ;
            XiaoMing xiaoMing = new XiaoMing(heater);

            //BeginInvoke 立即返回，不等待异步调用完成。
            //WatchTv函数会在输出当前温度前面执行
            //BeginInvoke 返回一个 IAsyncResult，后者可用于监视异步调用的进度
            IAsyncResult ar = xiaoMing.BeginBoilWater(, xiaoMing.Wash, "肥皂");
            xiaoMing.WatchTv();

            //在调用 BeginInvoke 之后随时可以调用
            // 如果异步调用尚未完成，则 EndInvoke 会一直阻止调用线程，直到异步调用完成
            // 如果放在EndBoilWater之后就会在输出当前温度后执行
            int currentTemp = xiaoMing.EndBoilWater(ar);

            Console.ReadLine();
        }

可以从输出结果上看到，小明开始烧水之后就去看电视了，并且水也在烧着。

从上面可以看到BeginInvoke返回IAsyncResult接口类型，那IAsyncResult到底是什么呢？

 //
    // 摘要:
    //     表示异步操作的状态。
    [ComVisible(true)]
    public interface IAsyncResult
    {
        //
        // 摘要:
        //     获取用户定义的对象，它限定或包含关于异步操作的信息。
        //
        // 返回结果:
        //     用户定义的对象，它限定或包含关于异步操作的信息。
        object AsyncState { get; }
        //
        // 摘要:
        //     获取用于等待异步操作完成的 System.Threading.WaitHandle。
        //
        // 返回结果:
        //     用于等待异步操作完成的 System.Threading.WaitHandle。
        WaitHandle AsyncWaitHandle { get; }
        //
        // 摘要:
        //     获取一个值，该值指示异步操作是否同步完成。
        //
        // 返回结果:
        //     如果异步操作同步完成，则为 true；否则为 false。
        bool CompletedSynchronously { get; }
        //
        // 摘要:
        //     获取一个值，该值指示异步操作是否已完成。
        //
        // 返回结果:
        //     如果操作完成则为 true，否则为 false。
        bool IsCompleted { get; }
    }

上面的属性可用于监视异步调用的进度。面下面的代码中使用while循环根据IsCompleted来判断异步是否完成

        static void Main(string[] args)
        {
            Heater heater = new Heater();
            heater.SetTemp = ;
            XiaoMing xiaoMing = new XiaoMing(heater);

            //BeginInvoke 立即返回，不等待异步调用完成。
            //WatchTv函数会在输出当前温度前面执行
            //BeginInvoke 返回一个 IAsyncResult，后者可用于监视异步调用的进度
            IAsyncResult ar = xiaoMing.BeginBoilWater(, xiaoMing.Wash, "肥皂");
            xiaoMing.WatchTv();
            int i = ;
            while (!ar.IsCompleted)
            {
                if (ar.IsCompleted)
                {
                    Console.WriteLine("水烧好了");
                }
                Console.WriteLine(i++);
            }

            //在调用 BeginInvoke 之后随时可以调用
            // 如果异步调用尚未完成，则 EndInvoke 会一直阻止调用线程，直到异步调用完成
            // 如果放在EndBoilWater之后就会在输出当前温度后执行
            int currentTemp = xiaoMing.EndBoilWater(ar);

            Console.ReadLine();
        }

从输出的i的值可以看到while会一直执行直到IsCompleted=true。然后使用AsyncWaitHandle来判断。

使用 IAsyncResult.AsyncWaitHandle 属性获取 WaitHandle，使用其 WaitOne 方法阻止执行，直至 WaitHandle 收到信号，然后调用 EndInvoke。其实它就是个信号量，当使用其Waitone()方法的时候，程序就会发生阻塞，如果异步完成，Waitone就会返回true，否则返回false。当然最方便的就是我们可以在Waitone中设置一个时间来做超时处理，比如我们可以在 BeginBoilWater代码后增加ar.AsyncWaitHandle.WaitOne(1000),由于，异步方法的线程需要10000ms，主线程等待了1000ms后，认为是超时了，便会继续执行后面老王看电视的代码。

        static void Main(string[] args)
        {
            Heater heater = new Heater();
            heater.SetTemp = ;
            XiaoMing xiaoMing = new XiaoMing(heater);

            //BeginInvoke 立即返回，不等待异步调用完成。
            //WatchTv函数会在输出当前温度前面执行
            //BeginInvoke 返回一个 IAsyncResult，后者可用于监视异步调用的进度
            IAsyncResult ar = xiaoMing.BeginBoilWater(, xiaoMing.Wash, "肥皂");
            ar.AsyncWaitHandle.WaitOne();
            xiaoMing.WatchTv();

            //在调用 BeginInvoke 之后随时可以调用
            // 如果异步调用尚未完成，则 EndInvoke 会一直阻止调用线程，直到异步调用完成
            // 如果放在EndBoilWater之后就会在输出当前温度后执行
            int currentTemp = xiaoMing.EndBoilWater(ar);

            Console.ReadLine();
        }

可以看到在WatchTv前使用AsyncWaitHandle.WaitOne()以看阻塞线程1000毫秒，可以看到看电视在异步线程开始一段时间才开始执行。假如也是使用while循环来输出，和前面的IsCompleted又不一样。

        static void Main(string[] args)
        {
            Heater heater = new Heater();
            heater.SetTemp = ;
            XiaoMing xiaoMing = new XiaoMing(heater);

            //BeginInvoke 立即返回，不等待异步调用完成。
            //WatchTv函数会在输出当前温度前面执行
            //BeginInvoke 返回一个 IAsyncResult，后者可用于监视异步调用的进度
            IAsyncResult ar = xiaoMing.BeginBoilWater(, xiaoMing.Wash, "肥皂");
            xiaoMing.WatchTv();
            int i = ;
            bool flag = true;
            while (flag)
            {
                flag = !ar.AsyncWaitHandle.WaitOne();
                Console.WriteLine(i++);
            }

            //在调用 BeginInvoke 之后随时可以调用
            // 如果异步调用尚未完成，则 EndInvoke 会一直阻止调用线程，直到异步调用完成
            // 如果放在EndBoilWater之后就会在输出当前温度后执行
            int currentTemp = xiaoMing.EndBoilWater(ar);

            Console.ReadLine();
        }

可以看到，输出i只执行了3次，并不像前面IsCompleted那样一直输出i，使用AsyncWaitHandle使线程阻塞，不再执行，直到信号量为true。