1、.NET 1.0 异步编程模型(APM)

时间 2020-05-17

标签 1.0 异步编程模型 apm 繁體版

原文原文链接

1、异步编程模型(APM) html

2、基于事件的异步编程模式(EAP)
spring

3、基于任务的异步模式(TAP)，推荐使用
编程

4、C# 5.0 新特性——Async和Await使异步编程更简单数组

1、概念

APM即异步编程模式的简写（Asynchronous Programming Model）。你们在写代码的时候或者查看.NET 的类库的时候确定会常常看到和使用以BeginXXX和EndXXX相似的方法，其实你在使用这些方法的时候，你就再使用异步编程模型来编写程序。NET Framework不少类也实现了该模式，同时咱们也能够自定义类来实现该模式，（也就是在自定义的类中实现返回类型为IAsyncResult接口的BeginXXX方法和EndXXX方法），另外委托类型也定义了BeginInvoke和EndInvoke方法。缓存

下面就具体就拿FileStream类的BeginRead和EndRead方法来介绍下下异步编程模型的实现。服务器

BeginXxx方法——开始执行异步操做介绍

当须要读取文件中的内容时，咱们一般会采用FileStream的同步方法Read来读取，该同步方法的定义为：异步

// 从文件流中读取字节块并将该数据写入给定的字节数组中
// array表明把读取的字节块写入的缓存区
// offset表明array的字节偏量，将在此处读取字节
// count 表明最多读取的字节数
public override int Read(byte[] array, int offset, int count )

该同步方法会堵塞执行的线程。能够经过BeginRead方法来实现异步编程，使读取操做再也不堵塞UI线程。BeginRead方法表明异步执行Read操做，并返回实现IAsyncResult接口的对象，该对象存储着异步操做的信息，下面就看下BeginRead方法的定义，看看与同步Read的方法区别在哪里的.async

// 开始异步读操做
// 前面的3个参数和同步方法表明的意思同样，这里就不说了，能够看到这里多出了2个参数
// userCallback表明当异步IO操做完成时，你但愿由一个线程池线程执行的方法,该方法必须匹配AsyncCallback委托
// stateObject表明你但愿转发给回调方法的一个对象的引用，在回调方法中，能够查询IAsyncResult接口的AsyncState属性来访问该对象
public override IAsyncResult BeginRead(byte[] array, int offset, int numBytes, AsyncCallback userCallback, Object stateObject
)

从上面的代码中能够看出异步方法和同步方法的区别，若是你在使用该异步方法时，不但愿异步操做完成后调用任何代码，你能够把userCallback参数设置为null。该异步方法子因此不会堵塞UI线程是由于调用该方法后，该方法会当即把控制权返回给调用线程(若是是UI线程来调用该方法时，即返回给UI线程)，然而同步却不是这样，同步方法是等该操做完成以后返回读取的内容以后才返回给调用线程，从而致使在操做完成以前调用线程就一直等待状态。ide

EndXxx方法——结束异步操做介绍

　前面介绍完了BeginXxx方法，咱们看到全部BeginXxx方法返回的都是实现了IAsyncResult接口的一个对象，并非对应的同步方法那样直接获得结果。此时咱们须要调用对应的EndXxx方法来结束异步操做，并向该方法传递IAsyncResult对象，EndXxx方法的返回类型就是和同步方法同样的。例如，FileStream的EndRead方法返回一个Int32来表明从文件流中实际读取的字节数。异步编程

// 摘要:  等待挂起的异步读取完成。
// asyncResult:对要完成的挂起异步请求的引用。
// 返回结果: 从流中读取的字节数.
public virtual int EndRead(IAsyncResult asyncResult);

对于访问异步操做的结果，APM的首选方式是：
使用 AsyncCallback委托来指定操做完成时要调用的方法，在操做完成后调用的方法中调用EndXxx操做来得到异步操做的结果。

异步编程模型的本质

其实异步编程模型这个模式，就是微软利用委托和线程池帮助咱们实现的一个模式(该模式利用一个线程池线程去执行一个操做，在FileStream类BeginRead方法中就是执行一个读取文件操做，该线程池线程会当即将控制权返回给调用线程，此时线程池线程在后台进行这个异步操做；异步操做完成以后，经过回调函数来获取异步操做返回的结果。此时就是利用委托的机制。因此说异步编程模式时利用委托和线程池线程搞出来的模式，包括后面的基于事件的异步编程和基于任务的异步编程，还有C# 5中的async和await关键字，都是利用这委托和线程池搞出来的。他们的本质其实都是同样的，只是后面提出来的使异步编程更加简单罢了。)

2、同步方法举例：

存储请求的状态类：

// 这个类存储请求的状态
    public class RequestState
    {
        public int BufferSize = 1024;
        public string savepath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\TAP.docx";
        public byte[] BufferRead;
        public HttpWebRequest request;
        public HttpWebResponse response;
        public Stream streamResponse;

        public FileStream filestream;

        public RequestState()
        {
            BufferRead = new byte[BufferSize];
            request = null;
            streamResponse = null;
            if (File.Exists(savepath))
            {
                File.Delete(savepath);
            }

            filestream = new FileStream(savepath, FileMode.OpenOrCreate);
        }
    }

主程序：

private static void Main(string[] args)
        {
            string downUrl = "http://download.microsoft.com/download/5/B/9/5B924336-AA5D-4903-95A0-56C6336E32C9/TAP.docx";

            // 同步下载文件
            //在下载操做完成以后咱们才能够看到"Start DownLoad File......." 消息显示
            DownLoadFileSync(downUrl);

            //异步下载文件
            //在下载操做完成以前咱们就能够看到"Start DownLoad File......." 消息显示
            // DownloadFileAsync(downUrl);

            Console.WriteLine("Start DownLoad File.........");
            Console.ReadLine();
        }

调用的是同步方法时，此时会堵塞主线程，直到文件的下载操做被完成以后主线程才继续执行后面的代码，下面是下载文件的同步方法：

private static void DownLoadFileSync(string url)
        {
            // 建立一个 RequestState 实例
            RequestState req = new RequestState();
            try
            {
                // 初始化一个  HttpWebRequest 对象
                HttpWebRequest myHttpWebRequest = (HttpWebRequest)WebRequest.Create(url);
                // 指派 HttpWebRequest实例到requestState的request字段.
                req.request = myHttpWebRequest;
                req.response = (HttpWebResponse)myHttpWebRequest.GetResponse();
                req.streamResponse = req.response.GetResponseStream();
                int readSize = req.streamResponse.

Read

(req.BufferRead, 0, req.BufferRead.Length);
                while (readSize > 0)
                {
                    req.filestream.Write(req.BufferRead, 0, readSize);
                    readSize = req.streamResponse.

Read

(req.BufferRead, 0, req.BufferRead.Length);
                }

                Console.WriteLine("\nThe Length of the File is: {0}", req.filestream.Length);
                Console.WriteLine("DownLoad Completely, Download path is: {0}", req.savepath);
            }
            catch (Exception e)
            {
                Console.WriteLine("Error Message is:{0}", e.Message);
            }
            finally
            {
                req.response.Close();
                req.filestream.Close();
            }
        }

使用同步方法下载文件的运行结果为：

3、异步方法（BeginXXX、EndXXX方法）举例：

控制台程序演示如何使用APM来现异步编程：

private static void DownloadFileAsync(string url)
        {
            try
            {
                HttpWebRequest myHttpWebRequest = (HttpWebRequest)WebRequest.Create(url);
                RequestState requestState = new RequestState();
                requestState.request = myHttpWebRequest;
                myHttpWebRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), requestState);
            }
            catch (Exception e)
            {
                Console.WriteLine("Error Message is:{0}", e.Message);
            }
        }

        //每一个异步操做完成时，将调用下面的方法
        private static void ResponseCallback(IAsyncResult callbackresult)
        {
            // 获取 RequestState 对象
            RequestState req = (RequestState)callbackresult.AsyncState;
            HttpWebRequest myHttpRequest = req.request;
            // 结束一个对英特网资源的的异步请求
            req.response = (HttpWebResponse)myHttpRequest.EndGetResponse(callbackresult);
            //从服务器获取响应流
            Stream responseStream = req.response.GetResponseStream();
            req.streamResponse = responseStream;
            //异步读取流到字节数组
            IAsyncResult asynchronousRead = responseStream.

BeginRead

(req.BufferRead, 0, req.BufferRead.Length, ReadCallBack, req);
        }

        // 写字节数组到 FileStream
        private static void ReadCallBack(IAsyncResult asyncResult)
        {
            try
            {
                // 获取 RequestState 对象
                RequestState req = (RequestState)asyncResult.AsyncState;
                //从RequestState对象中获取 Response Stream
                Stream responserStream = req.streamResponse;
                //
                int readSize = responserStream.EndRead(asyncResult);
                if (readSize > 0)
                {
                    req.filestream.Write(req.BufferRead, 0, readSize);
                    responserStream.BeginRead(req.BufferRead, 0, req.BufferRead.Length, ReadCallBack, req);//循环调用ReadCallBack方法。
                }
                else
                {
                    Console.WriteLine("\nThe Length of the File is: {0}", req.filestream.Length);
                    Console.WriteLine("DownLoad Completely, Download path is: {0}", req.savepath);
                    req.response.Close();
                    req.filestream.Close();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error Message is:{0}", e.Message);
            }
        }

运行结果为（从运行结果也能够看出，在主线程中调用 DownloadFileAsync(downUrl)方法时，DownloadFileAsync(downUrl)方法中的req.BeginGetResponse调用被没有阻塞调用线程(即主线程)，而是当即返回到主线程，是主线程后面的代码能够当即执行）

4、委托实例的异步调用（BeginInvoke、EndInvoke方法）

在前面的介绍中已经提到委托类型也会定义了BeginInvoke方法和EndInvoke方法，因此委托类型也实现了异步编程模型，因此可使用委托的BeginInvoke和EndInvoke方法来回调同步方法从而实现异步编程。由于调用委托的BeginInvoke方法来执行一个同步方法时，此时会使用线程池线程回调这个同步方法并当即返回到调用线程中，因为耗时操做在另一个线程上运行，因此执行BeginInvoke方法的主线程就不会被堵塞。下面实如今线程池线程中如何更新GUI线程中窗体。

// 定义用来实现异步编程的委托
        private delegate string AsyncMethodCaller(string fileurl);

       private void btnDownLoad_Click(object sender, EventArgs e)
        {
          AsyncMethodCaller methodCaller = new AsyncMethodCaller(DownLoadFileSync);//DownLoadFileSync为同步下载文件的方法
            methodCaller.

BeginInvoke

(txbUrl.Text.Trim(),

GetResult

, null);
        }

        // 异步操做完成时执行的方法
        private void GetResult(IAsyncResult result)
        {
            AsyncMethodCaller caller = (AsyncMethodCaller)((AsyncResult)result).AsyncDelegate;// 或者(AsyncMethodCaller)result.AsyncState;
            // 调用EndInvoke去等待异步调用完成而且得到返回值
            // 若是异步调用还没有完成，则 EndInvoke 会一直阻止调用线程，直到异步调用完成
          try{

            string returnstring = caller.EndInvoke(result);

          catch (Exception ex){}

// 而后Invoke方法来使更新GUI操做方法由GUI 线程去执行
            Invoke(new MethodInvoker(delegate()
            {
                rtbState.Text = returnstring;
                btnDownLoad.Enabled = true;
            }));
        }

运行的结果为：

上例子中使用了控件的Invoke方式进行异步回调访问控件的方法，其背后是经过得到GUI线程的同步上文对象，而后同步调用同步上下文对象的post方法把要调用的方法交给GUI线程去处理。

          // 定义用来实现异步编程的委托
            private delegate string AsyncMethodCaller(string fileurl);

            // 定义显示状态的委托
            private delegate void ShowStateDelegate(string value);
            private ShowStateDelegate showStateCallback;

            SynchronizationContext sc;

            public MainForm()
            {
                InitializeComponent();
                txbUrl.Text = "http://download.microsoft.com/download/7/0/3/703455ee-a747-4cc8-bd3e-98a615c3aedb/dotNetFx35setup.exe";
                showStateCallback = new ShowStateDelegate(ShowState);
            }

            private void btnDownLoad_Click(object sender, EventArgs e)
            {

                AsyncMethodCaller methodCaller = new AsyncMethodCaller(DownLoadFileSync);
                methodCaller.BeginInvoke(txbUrl.Text.Trim(), GetResult, null);

                // 捕捉调用线程的同步上下文派生对象

sc =

 SynchronizationContext.Current;
            }


            // 异步操做完成时执行的方法
            private void GetResult(IAsyncResult result)
            {
                AsyncMethodCaller caller = (AsyncMethodCaller)((AsyncResult)result).AsyncDelegate;

                string returnstring = caller.EndInvoke(result);

                // 经过得到GUI线程的同步上下文的派生对象，而后调用Post方法来使更新GUI操做方法由GUI 线程去执行
                sc.Post(ShowState, returnstring);
            }

            // 显示结果到richTextBox，由于该方法是由GUI线程执行的，因此固然就能够访问窗体控件了
            private void ShowState(object result)
            {
                rtbState.Text = result.ToString();
                btnDownLoad.Enabled = true;
            }

5、综合实例

假如如今有这样的一个需求，咱们须要从3个txt文件中读取字符，而后进行倒序，前提是不能阻塞主线程。若是不用task的话我可能会用工做线程去监视一个bool变量来判断文件是否所有读取完毕，而后再进行倒序，我也说了，相对task来讲仍是比较麻烦的，这里我就用task来实现。

static byte[] b;

        static void Main()
        {
            string[] array = { "C://1.txt", "C://2.txt", "C://3.txt" };

            List<Task<string>> taskList = new List<Task<string>>(3);

            foreach (var item in array)
            {
                taskList.Add(ReadAsyc(item));
            }

            Task.Factory.ContinueWhenAll(taskList.ToArray(), i =>
            {
                string result = string.Empty;

                //获取各个task返回的结果
                foreach (var item in i)
                {
                    result += item.Result;
                }

                //倒序
                String content = new String(result.OrderByDescending(j => j).ToArray());

                Console.WriteLine("倒序结果："+content);
            });

            Console.WriteLine("我是主线程，我不会被阻塞");

            Console.ReadKey();
        }

        //异步读取
        static Task<string> ReadAsyc(string path)
        {
            FileInfo info = new FileInfo(path);

            byte[] b = new byte[info.Length];

            FileStream fs = new FileStream(path, FileMode.Open);

            Task<int> task = Task<int>.Factory.FromAsync(fs.BeginRead, fs.EndRead, b, 0, b.Length, null, TaskCreationOptions.None);

            //返回当前task的执行结果
            return task.ContinueWith(i =>
            {
                return i.Result > 0 ? Encoding.Default.GetString(b) : string.Empty;
            }, TaskContinuationOptions.ExecuteSynchronously);
        }

6、小结

　　到这里本专题关于异步编程模型的介绍就结束了，异步编程模型（APM）虽然是.NET 1.0中提出来的一个模式，相对于如今来讲是旧了点，而且微软如今官方也代表在最新的代码中不推荐使用该模型来实现异步的应用程序，而是推荐使用基于任务的异步编程模型来实现异步的应用程序，可是我我的认为，正是由于它是.NET 1.0中提出的来，而且如今来看确实有些旧了，因此咱们才更应该好好研究下它，由于后面提出的EAP和TAP微软作了更多的封装，是咱们对异步编程的本质都不清楚的（其实它们的本质都是使用线程池和委托机制的，具体能够查看前面的相关部分），而且系统学习下异步编程，也可让咱们对新的异步编程模型的所带来的好处有更可直观的认识。在后面的一专题我将带你们全面认识下基于事件的异步编程模型（EAP）。