C#编程总结（六）异步编程

时间 2019-11-09

标签 c# 编程总结异步栏目 C# 繁體版

原文原文链接

C#编程总结（六）异步编程

一、什么是异步？

异步操做一般用于执行完成时间可能较长的任务，如打开大文件、链接远程计算机或查询数据库。异步操做在主应用程序线程之外的线程中执行。应用程序调用方法异步执行某个操做时，应用程序可在异步方法执行其任务时继续执行。数据库

二、同步与异步的区别

同步（Synchronous）：在执行某个操做时，应用程序必须等待该操做执行完成后才能继续执行。编程

异步（Asynchronous）：在执行某个操做时，应用程序可在异步操做执行时继续执行。实质：异步操做，启动了新的线程，主线程与方法线程并行执行。设计模式

三、异步和多线程的区别

咱们已经知道，异步的实质是开启了新的线程。它与多线程的区别是什么呢？缓存

简单的说就是：异步线程是由线程池负责管理，而多线程，咱们能够本身控制，固然在多线程中咱们也可使用线程池。网络

就拿网络扒虫而言，若是使用异步模式去实现，它使用线程池进行管理。异步操做执行时，会将操做丢给线程池中的某个工做线程来完成。当开始I/O操做的时候，异步会将工做线程还给线程池，这意味着获取网页的工做不会再占用任何CPU资源了。直到异步完成，即获取网页完毕，异步才会经过回调的方式通知线程池。可见，异步模式借助于线程池，极大地节约了CPU的资源。多线程

注：DMA（Direct Memory Access）直接内存存取，顾名思义DMA功能就是让设备能够绕过处理器，直接由内存来读取资料。经过直接内存访问的数据交换几乎能够不损耗CPU的资源。在硬件中，硬盘、网卡、声卡、显卡等都有直接内存访问功能。异步编程模型就是让咱们充分利用硬件的直接内存访问功能来释放CPU的压力。
二者的应用场景：dom

计算密集型工做，采用多线程。
IO密集型工做，采用异步机制。异步

四、异步应用

.NET Framework 的许多方面都支持异步编程功能，这些方面包括：
1）文件 IO、流 IO、套接字 IO。
2）网络。
3）远程处理信道（HTTP、TCP）和代理。
4）使用 ASP.NET 建立的 XML Web services。
5）ASP.NET Web 窗体。
6）使用 MessageQueue 类的消息队列。异步编程

.NET Framework 为异步操做提供两种设计模式：
1）使用 IAsyncResult 对象的异步操做。
2）使用事件的异步操做。
IAsyncResult 设计模式容许多种编程模型，但更加复杂不易学习，可提供大多数应用程序都不要求的灵活性。可能的话，类库设计者应使用事件驱动模型实现异步方法。在某些状况下，库设计者还应实现基于 IAsyncResult 的模型。学习

使用 IAsyncResult 设计模式的异步操做是经过名为 Begin操做名称和End操做名称的两个方法来实现的，这两个方法分别开始和结束异步操做操做名称。例如，FileStream 类提供 BeginRead 和 EndRead 方法来从文件异步读取字节。这两个方法实现了 Read 方法的异步版本。在调用 Begin操做名称后，应用程序能够继续在调用线程上执行指令，同时异步操做在另外一个线程上执行。每次调用 Begin操做名称时，应用程序还应调用 End操做名称来获取操做的结果。Begin操做名称方法开始异步操做操做名称并返回一个实现 IAsyncResult 接口的对象。 .NET Framework 容许您异步调用任何方法。定义与您须要调用的方法具备相同签名的委托；公共语言运行库将自动为该委托定义具备适当签名的 BeginInvoke 和 EndInvoke 方法。

IAsyncResult 对象存储有关异步操做的信息。下表提供了有关异步操做的信息。

名称	说明
AsyncState	获取用户定义的对象，它限定或包含关于异步操做的信息。
AsyncWaitHandle	获取用于等待异步操做完成的 WaitHandle。
CompletedSynchronously	获取一个值，该值指示异步操做是否同步完成。
IsCompleted	获取一个值，该值指示异步操做是否已完

五、应用实例

案例1-读取文件

一般读取文件是一个比较耗时的工做，特别是读取大文件的时候，常见的上传和下载。可是咱们又不想让用户一直等待，用户一样能够进行其余操做，可使得系统有良好的交互性。这里咱们写了同步调用和异步调用来进行比较说明。

读取文件类

using System;
using System.IO;
using System.Threading;

namespace AsynSample
{
    class FileReader
    {
        /// <summary>
        /// 缓存池
        /// </summary>
        private byte[] Buffer { get; set; }
        /// <summary>
        /// 缓存区大小
        /// </summary>
        public int BufferSize { get; set; }

        public FileReader(int bufferSize)
        {
            this.BufferSize = bufferSize;
            this.Buffer = new byte[BufferSize];
        }

        /// <summary>
        /// 同步读取文件
        /// </summary>
        /// <param name="path">文件路径</param>
        public void SynsReadFile(string path)
        {
            Console.WriteLine("同步读取文件 begin");
            using (FileStream fs = new FileStream(path, FileMode.Open))
            {                
                fs.Read(Buffer, 0, BufferSize);
                string output = System.Text.Encoding.UTF8.GetString(Buffer);
                Console.WriteLine("读取的文件信息：{0}",output);
            }
           
            Console.WriteLine("同步读取文件 end");
        }
        /// <summary>
        /// 异步读取文件
        /// </summary>
        /// <param name="path"></param>
        public void AsynReadFile(string path)
        {
            Console.WriteLine("异步读取文件 begin");
            //执行Endread时报错，fs已经释放，注意在异步中不能使用释放须要的资源
            //using (FileStream fs = new FileStream(path, FileMode.Open))
            //{
            //    Buffer = new byte[BufferSize];
            //    fs.BeginRead(Buffer, 0, BufferSize, AsyncReadCallback, fs);
            //} 
            if (File.Exists(path))
            {
                FileStream fs = new FileStream(path, FileMode.Open);
                fs.BeginRead(Buffer, 0, BufferSize, AsyncReadCallback, fs);
            }
            else
            {
                Console.WriteLine("该文件不存在");
            }

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ar"></param>
        void AsyncReadCallback(IAsyncResult ar)
        {
            FileStream stream = ar.AsyncState as FileStream;
            if (stream != null)
            {
                Thread.Sleep(1000);
                //读取结束
                stream.EndRead(ar);
                stream.Close();

                string output = System.Text.Encoding.UTF8.GetString(this.Buffer);
                Console.WriteLine("读取的文件信息：{0}", output);
            }
        }
    }
}

测试用例

using System;
using System.Threading;

namespace AsynSample
{
    class Program
    {
        static void Main(string[] args)
        {
            FileReader reader = new FileReader(1024);

            //改成本身的文件路径
            string path = "C:\\Windows\\DAI.log";

            Console.WriteLine("开始读取文件了...");
            //reader.SynsReadFile(path);

            reader.AsynReadFile(path);

            Console.WriteLine("我这里还有一大滩事呢.");
            DoSomething();
            Console.WriteLine("终于完事了，输入任意键，歇着！");
            Console.ReadKey();           
        }
        /// <summary>
        /// 
        /// </summary>
        static void DoSomething()
        {
            Thread.Sleep(1000);
            for (int i = 0; i < 10000; i++)
            {
                if (i % 888 == 0)
                {
                    Console.WriteLine("888的倍数：{0}",i);
                }
            }
        }
    }
}

输出结果：

同步输出：

异步输出：

结果分析：

若是是同步读取，在读取时，当前线程读取文件，只能等到读取完毕，才能执行如下的操做

而异步读取，是建立了新的线程，读取文件，而主线程，继续执行。咱们能够开启任务管理器来进行监视。

案例二--基于委托的异步操做

系统自带一些类具备异步调用方式，如何使得自定义对象也具备异步功能呢？

咱们能够借助委托来轻松实现异步。

说到BeginInvoke，EndInvoke就不得不停下来看一下委托的本质。为了便于理解委托，我定义一个简单的委托：

public delegate string MyFunc(int num, DateTime dt);

咱们再来看一下这个委托在编译后的程序集中是个什么样的：

委托被编译成一个新的类型，拥有BeginInvoke，EndInvoke，Invoke这三个方法。前二个方法的组合使用即可实现异步调用。第三个方法将以同步的方式调用。其中BeginInvoke方法的最后二个参数用于回调，其它参数则与委托的包装方法的输入参数是匹配的。 EndInvoke的返回值与委托的包装方法的返回值匹配。

异步实现文件下载：

using System;
using System.Text;

namespace AsynSample
{
    /// <summary>
    /// 下载委托
    /// </summary>
    /// <param name="fileName"></param>
    public delegate string AysnDownloadDelegate(string fileName);
    /// <summary>
    /// 经过委托实现异步调用
    /// </summary>
    class DownloadFile
    {
        /// <summary>
        /// 同步下载
        /// </summary>
        /// <param name="fileName"></param>
        public string Downloading(string fileName)
        {
            string filestr = string.Empty;
            Console.WriteLine("下载事件开始执行");
            System.Threading.Thread.Sleep(3000);
            Random rand = new Random();
            StringBuilder builder =new StringBuilder();
            int num;
            for(int i=0;i<100;i++)
            {
                num = rand.Next(1000);
                builder.Append(i);
            }
            filestr = builder.ToString();
            Console.WriteLine("下载事件执行结束");

            return filestr;
        }
        /// <summary>
        /// 异步下载
        /// </summary>
        public IAsyncResult BeginDownloading(string fileName)
        {
            string fileStr = string.Empty;
            AysnDownloadDelegate downloadDelegate = new AysnDownloadDelegate(Downloading);
            return downloadDelegate.BeginInvoke(fileName, Downloaded, downloadDelegate);
        }
        /// <summary>
        /// 异步下载完成后事件
        /// </summary>
        /// <param name="result"></param>
        private void Downloaded(IAsyncResult result)
        {
            AysnDownloadDelegate aysnDelegate = result.AsyncState as AysnDownloadDelegate;
            if (aysnDelegate != null)
            {
                string fileStr = aysnDelegate.EndInvoke(result);
                if (!string.IsNullOrEmpty(fileStr))
                {
                    Console.WriteLine("下载文件：{0}", fileStr);
                }
                else
                {
                    Console.WriteLine("下载数据为空!");
                }
            }
            else
            {
                Console.WriteLine("下载数据为空!");
            }
        }
    }
}

经过案例，咱们发现，使用委托可以很轻易的实现异步。这样，咱们就能够自定义本身的异步操做了。