c#中异步编程模型变迁及如何使用异步

大家在编程过程中都会用到一些异步编程的情况。在c#的BCL中，很多api都提供了异步方法，初学者可能对各种不同异步方法的使用感到迷惑，本文主要为大家梳理一下异步方法的变迁以及如何使用异步方法。

BeginXXX，EndXXX模式

在.Net Framework 2.0中，最常见的方法是BeginXXX，和EndXXX这样的方法来搭配使用。这种模式可以概括为方法+回调方法模式或者称为InvokeMethod+EventHandler模式。

这种模型的基本流程是：

    调用BeginXXX方法
    BeginXXX方法中传入一个回调方法，这个回调方法会在异步方法执行结束后被执行
    调用EndXXX方法，使用EndXXX方法会阻塞当前线程，直到异步方法返回结果。

我们看一个FileStream的示例方法，在.Net 2.0中，你需要这样使用异步：

using System;
using System.IO;
using System.Text;
 
public class AsyncTest
{
    public static void Main(string[] args)
    {
        using (FileStream file = new FileStream("Test.txt", FileMode.OpenOrCreate))
        {
            var bytes = Encoding.UTF8.GetBytes("Test for .net framework 2.0");
 
            IAsyncResult asyncResult = file.BeginWrite(bytes, 0, bytes.Length, callback, null);
 
            file.EndWrite(asyncResult);
        }
 
        Console.ReadLine();
    }
 
    private static void callback(IAsyncResult ar)
    {
        Console.WriteLine("Finish Write");
    }
}

XXXAsync模式

从.Net 4.0开始，微软引入了Task。由于Task本身的灵活性，也使得我们的异步编程模型更简洁。上面的例子在.Net 4.5中可以这样实现：

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
 
public class AsyncTest
{
    public static void Main(string[] args)
    {
        using (FileStream file = new FileStream("Test.txt", FileMode.OpenOrCreate))
        {
            var bytes = Encoding.UTF8.GetBytes("Test for .net framework 4.5");
 
            var task = file.WriteAsync(bytes, 0, bytes.Length);
 
            task.Wait();
        }
 
        Console.ReadLine();
    }
}

微软在许多BCL的api中都添加了XXXAsync方法来实现新的异步模型。Task本身比回调方法灵活了许多，可以更优雅的实现回调，取消，调度等操作。关于Task的使用方式可以看我之前总结的文章link。

async和await模型

为了进一步简化异步模型，微软从Visual Studio 2012开始引入了async和await关键字。这个模型本身是基于编译器的一个语法糖，编译后会生成一个statemachine模型。这样上面例子中的写法也可以简化成：

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
 
public class AsyncTest
{
    public static void Main(string[] args)
    {
        TestFunc();
    }
 
    private static async void TestFunc()
    {
        using (FileStream file = new FileStream("Test.txt", FileMode.OpenOrCreate))
        {
            var bytes = Encoding.UTF8.GetBytes("Test for .net framework 4.5");
            await file.WriteAsync(bytes, 0, bytes.Length);
        }
    }
}

关于异步编程模型的兼容性

如果大家注意看BCL中的类库，会发现微软并没有在最新版本的类库中对每一个BeginXXX的方法都添加了XXXAsync方法。这种情况下我们如何能让新的异步模型兼容旧的方法呢？

以NamedPipeServerStream为例，这个类库实现了一个管道的功能，微软并没有为其更新XXXAsync方法，你可以使用TaskFactory来兼容新的异步模型，你可以这样来实现：

private static void OldAsyncModel()
{
    NamedPipeServerStream pipe = new NamedPipeServerStream("customPipe", PipeDirection.InOut, -1, PipeTransmissionMode.Message, PipeOptions.Asynchronous | PipeOptions.WriteThrough);
    IAsyncResult async = pipe.BeginWaitForConnection(callback, null);
    pipe.EndWaitForConnection(async);
}
 
private static async void NewAsyncModel()
{
    NamedPipeServerStream pipe = new NamedPipeServerStream("customPipe", PipeDirection.InOut, -1, PipeTransmissionMode.Message, PipeOptions.Asynchronous | PipeOptions.WriteThrough);
 
    await Task.Factory.FromAsync(pipe.BeginWaitForConnection, pipe.EndWaitForConnection, null);
}

　　

因此，我们可以总结为，.Net中有两种异步编程模型：

    不返回Task对象的调用方法+回调方法的模型
    返回Task对象的XXXAsync模型，和async，await模型

BeginXXX模型微软已经逐渐的考虑废弃，返回Task的异步编程模型目前是微软建议的方式。



c#中的异步编程模型

在读文件的时候，如果不采用异步模型，整个执行线程会挂起，直至文件读取完毕，这个时候这个线程就会一直等待直到文件读取完成为止极大的浪费资源；如果是从网络上读取文件的话，如果网络中断那么就只能抛出异常了（而线程只能忙等）。

public IAsyncResult BeginReceive(
 IList> buffers,
 SocketFlags socketFlags,
 AsyncCallback callback,
 Object state)
public int EndReceive(
 IAsyncResult asyncResult）

异步模型：必然有第三，第四个参数（两者可以置为null），并返回一个IAsyncResult的类型，异步期间采用硬件驱动监听，而不需要任何线程在这里等待；
异步编程模型的三个技术要点：第四个参数是传递给回调函数的

1.采用：人工调节

BeginReceive();
...
...
EndReceive();

自己采用一个适当的时间，在EndReceive()中返回本应该在同步模型中返回的值，如此处返回int，Accept()返回一个socket，但是这导致根本没有发挥出异步的全部能力。

等待直至完成：在执行到End..函数的时候就会默认静止，从而只能节省一部分时间；

2.间歇查询

public interface IAsyncResult {
 Object AsyncState { get; }
 WaitHandle AsyncWaitHandle { get; }
 Boolean IsCompleted { get; }
 Boolean CompletedSynchronously { get; }  //不需要使用
}

线程询问：

IAsyncResult ar = fs.BeginRead(data, 0, data.Length, null, null);
while (!ar.IsCompleted) {
 Console.WriteLine("Operation not completed; still waiting.");
 Thread.Sleep(10);
}                    //直到可以确定完成了
Int32 bytesRead = fs.EndRead(ar);

类似的有：

while (!ar.AsyncWaitHandle.WaitOne(10, false)) {
Console.WriteLine("Operation not completed; still waiting.");
}
Int32 bytesRead = fs.EndRead(ar);

3.回调函数

delegate void AsyncCallback(IAsyncResult ar); 回调函数的委托(回调函数实现采用相同类型的参数，直接传入函数名)
默认将第四个object参数转换为回调函数的相应的IAsyncResult参数。
object 是一个传递给回调函数的任意类型的参数，但是要用IAsyncResult的AsyncState来显示转换
在回调函数中调用end..函数，彻底完成异步操作。（回调函数可能不是定义在一个类中）
但是在回调函数可能要和异步开始调用的函数中公用一些数据，如，写文件时候的缓冲区。

优化方法：

1.定义一个类包含一些公用的数据，然后在主函数中声明实例，然后将其做为最后一个参数传递给回调函数。（可以防止过多的静态的数据）
2.匿名委托：（解决data共享问题）

fs.BeginRead(data, 0, data.Length,
delegate(IAsyncResult ar)
{
 Int32 bytesRead = fs.EndRead(ar);    注：用什么调用begin..，就一定要用它来调用end...
 fs.Close();
 Console.WriteLine(BitConverter.ToString(data, 0, bytesRead));
},    null);

3.让每一个异步操作采用自己的一对处理函数，来达到效率的最高。


委托的异步操作模型：
internal sealed class SumDelegate : MulticastDelegate {
 public SumDelegate(Object object, IntPtr method);
 public UInt64 Invoke(UInt64 n);
 public IAsyncResult BeginInvoke(UInt64 n, AsyncCallback callback, Object object);
 public UInt64 EndInvoke(IAsyncResult result);}