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

1、什么是异步？

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

2、同步与异步的区别

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

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

3、异步和多线程的区别

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

简单的说就是：异步线程是由线程池负责管理，而多线程，我们可以自己控制，当然在多线程中我们也可以使用线程池。

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

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

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

4、异步应用

.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 对象存储有关异步操作的信息。下表提供了有关异步操作的信息。

5、应用实例

案例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("下载数据为空!");
            }
        }
    }
}

通过案例，我们发现，使用委托能够很轻易的实现异步。这样，我们就可以自定义自己的异步操作了。