C#异步操作(APM)

同步：执行一个耗时的操作时，主线程就会一直等待，直到该操作执行完成，我们大部分程序都是同步操作。例如，你给朋友发了一个消息：一起玩王者农药，但是此时你朋友正在游戏中，你为了他能带你躺赢，你就一直等待他把这局打完，然后一起开黑。

异步：执行一个耗时的操作时，主线程不会等待，会继续执行下面的操作，当耗时的操作完成时，它会通过回调的方式告诉主线程我执行完了，然后主程序在回调函数里继续后续的操作。例如，你给朋友发了一个消息：一起玩王者农药，但是此时你朋友正在游戏中，虽然他是大神，你为了证明自己不是坑，不用他带依然可以上分，果断单独开了一局，等你朋友虐菜完成，通知你说，我打完了，要不要我带你飞。

IO操作

static void Main(string[] args)

{

Console.WriteLine("Start");

using (FileStream fs = new FileStream("Data.dxf", FileMode.OpenOrCreate, FileAccess.Read, FileShare.None))

{

fs.Read(new byte[1024], 0, 1024);

}

Console.WriteLine("End");

}

IO流操作使我们程序开发中很常见的与硬盘的交互方式，如: 上面代码中Data.dxf文件很大，fs.Read读取过程中，我们只能一直等待Read方法执行完，才能打印“End”。程序主界面一定会处于卡死状态，用户体验较差，此时我们就需要用到异步方式去读取文件流。如何去执行异步操作呢?

BeginXXX / EndXXX

static void Main(string[] args)

{

Console.WriteLine("Start");

using (FileStream fs = new FileStream("Data.dxf", FileMode.OpenOrCreate, FileAccess.Read, FileShare.None))

{

fs.BeginRead(new byte[1024], 0, 1024, null, null);//FileStream提供了异步调用的方法

}

Console.WriteLine("End");

}

.Net早期，采用BeginXXX/EndXXX方式实现异步,你在使用这些方法的时候，你就在使用异步编程模型来编写程序。异步编写模型是一种模式，该模式允许用更少的线程去做更多的操作，.NET Framework很多类也实现了该模式，例如上面的FileStream(实现返回类型为IAsyncResult接口的BeginXXX和EndXXX方法)，委托也定义了BeginInvoke和EndInvoke的方法。经常看到和使用类似BeginXXX和EndXXX方法，即是采用APM即异步编程模型（Asynchronous Programming Model）

我们先抛开IO的例子,先看一个委托的同步方法实例。

static void Main(string[] args)

{

Action<string> action = DoSomething; //实例化委托

action.Invoke("DoSomething Start"); //同步执行

Console.WriteLine("go on");

}

static void DoSomething(string s)

{

Console.WriteLine(s);

Console.WriteLine(Thread.CurrentThread.IsThreadPoolThread == true ? "pool thread" : "not pool thread"); //是否是线程池

Thread.Sleep(8000);

Console.WriteLine("DoSomething End");

}

执行结果:

DoSomething Start

not pool thread

DoSomething End

go on

调用Invoke方法，主线程就会等待DoSomething执行完，再继续往下执行。

现在换成BeginInvoke再打印一下结果

static void Main(string[] args)

{

Action<string> action = DoSomething; //实例化委托

action.BeginInvoke("DoSomething Start", null, null); //异步执行

Console.WriteLine("go on");

}

输出结果：

go on

DoSomething Start

pool thread

DoSomething End

调用BeginInvoke后，主线程根本不会等待DoSomething执行完成，就打印了“go on！”。还有一点，DoSomething方法里面的线程是线程池提供的线程，也就是BeginInvoke的异步操作是基于线程池实现的。

AsyncCallback、IAsyncResult

在上面代码中我们可以看到BeginInvoke方法里面有两个参数为null，这两个参数难道没作用吗？非也。看一下BeginInvoke的方法参数构造。

第一个参数：DoSomething方法中的参数，如果DoSomething方法没有参数，则BeginInvoke就只有后面两个参数

第二个参数：AsyncCallback callback，看一下AsyncCallback这是个什么东东？

namespace System

{

// 摘要:

// 引用在相应异步操作完成时调用的方法。

// 参数:

// ar:

// 异步操作的结果。

[Serializable]

[ComVisible(true)]

public delegate void AsyncCallback(IAsyncResult ar);

}

哦，原来是一个委托，没有返回值，接收一个IAsyncResult类型的参数。

1	AsyncCallback callback = ac => Console.WriteLine("This is Callback {0}", Thread.CurrentThread.ManagedThreadId);

上面用Lambda表达式实例化一个AsyncCallback,如果对lambda表达式不是很懂，请看这篇文章：Lambda表达式和Linq

static void Main(string[] args)

{

Action<string> action = DoSomething;

AsyncCallback callback = ac => Console.WriteLine("This is Callback {0}", Thread.CurrentThread.ManagedThreadId);

action.BeginInvoke("DoSomething Start", callback, null);

Console.WriteLine("go on");

}

执行结果:

go on

DoSomething Start

pool thread

DoSomething End

This is Callback 3

从结果中我们看到：最后一句是在异步完成之后打印的，其实这就是我们异步回调后的操作。你可能会问这个ac代表了什么，从委托AsyncCallback的参数中我们可以推断出ac就是IAsyncResult类型的实例。但是这个IAsyncResult的实例从哪里来的呢？也没见传进来就执行通过了。

static void Main(string[] args)

{

Action<string> action = DoSomething;

IAsyncResult iAsyncResult = null; //定义

AsyncCallback callback = ac =>

{

Console.WriteLine(string.ReferenceEquals(ac, iAsyncResult)); //判断ac和iAsyncResult是否相等

};

iAsyncResult = action.BeginInvoke("DoSomething Start", callback, null);

}

BeginInvoke方法的返回值是iAsyncResult,上面代码输出结果为”true”，所以ac就是BeginInvoke的返回值iAsyncResult，AsyncCallback这个委托就是执行异步后续的操作。

再来看一下IAsyncResult接口构造

public interface IAsyncResult

{

// 摘要:

// 获取用户定义的对象，它限定或包含关于异步操作的信息。

object AsyncState { get; }

// 摘要:

// 获取用于等待异步操作完成的 System.Threading.WaitHandle。

WaitHandle AsyncWaitHandle { get; }

// 摘要:

// 获取一个值，该值指示异步操作是否同步完成。

bool CompletedSynchronously { get; }

// 摘要:

// 获取一个值，该值指示异步操作是否已完成。

bool IsCompleted { get; }

}

IAsyncResult存储了异步方法的相关状态信息，其中AsyncState属性存储了BeginInvoke方面里面第三个参数。下面我们自己写一个简单的两个数字相加异步调用的例子

自定义IAsyncResult

public class WydAsyncResult : IAsyncResult

{

private readonly object obj_State;

private readonly AsyncCallback async_callback;

private ManualResetEvent m_AsyncWaitHandle; //信号量

public WydAsyncResult(int num1, int num2, AsyncCallback callback, object objState)

{

this.obj_State = objState;

this.async_callback = callback;

m_AsyncWaitHandle = new ManualResetEvent(false);//非终止状态

}

public void SetComplete() //异步完成

{

IsCompleted = true;

if (m_AsyncWaitHandle != null)

m_AsyncWaitHandle.Set();//终止

if (async_callback != null)

async_callback(this);//执行回调

}

public int Result //倆数值相加的结果

{

get;

set;

}

public object AsyncState

{

get { return obj_State; }

}

public WaitHandle AsyncWaitHandle

{

get { return m_AsyncWaitHandle; }

}

public bool CompletedSynchronously

{

get { return false; }

}

public bool IsCompleted

{

get;

private set;

}

调用类WydAsyncTask

public class WydAsyncTask

{

/// <summary>

/// 开始异步方法

/// </summary>

/// <param name="num1">数字1</param>

/// <param name="num2">数字2</param>

/// <param name="callback">AsyncCallback</param>

/// <param name="state">要传入的参数</param>

/// <returns></returns>

public IAsyncResult BeginAsyncTask(int num1, int num2, AsyncCallback callback, object state)

{

WydAsyncResult mr = new WydAsyncResult(num1, num2, callback, state);

ThreadPool.QueueUserWorkItem(t =>

{

mr.Result = num1 + num2;//此处执行你的需求

mr.SetComplete();//告知异步完成

});//线程池

return mr;

}

/// <summary>

/// 结束异步方法得到最终结果

/// </summary>

/// <param name="asyncResult">IAsyncResult</param>

/// <returns>返回二者之和</returns>

public int EndAsyncTask(IAsyncResult asyncResult)

{

WydAsyncResult result = asyncResult as WydAsyncResult;

if (!result.IsCompleted)

result.AsyncWaitHandle.WaitOne(); //阻塞线程

return result.Result;

}

/// <summary>

/// 同步方法

/// </summary>

/// <param name="num1">数字1</param>

/// <param name="num2">数字2</param>

/// <returns>返回二者之和</returns>

public int Task(int num1, int num2)

{

int result = num1 + num2;

return result;

}

Main方法调用

static void Main(string[] args)

{

WydAsyncTask asyncTask = new WydAsyncTask();

int result =asyncTask.Task(2, 3);//同步调用

Console.WriteLine("同步Result=" + result.ToString());

AsyncCallback callback = ac => { Console.WriteLine(ac.AsyncState.ToString()); };

IAsyncResult iAsyncResult = asyncTask.BeginAsyncTask(2, 3, callback, "callbacking");

result = asyncTask.EndAsyncTask(iAsyncResult);

Console.WriteLine("异步Result=" + result.ToString());

Console.ReadKey();

}

输出结果：

同步Result=5

异步Result=5

callbacking

同步调用可以直接返回Int结果，异步调用就需要调用EndAsyncTask方法才能取得Int结果。回调函数里面ac.AsyncState的值就是传入的callbacking。

对于访问异步操作的结果，APM提供了四种方式供开发人员选择：

在调用BeginXxx方法的线程上调用EndXxx方法来得到异步操作的结果，但是这种方式会阻塞调用线程，知道操作完成之后调用线程才继续运行
查询IAsyncResult的AsyncWaitHandle属性，从而得到WaitHandle，然后再调用它的WaitOne方法来使一个线程阻塞并等待操作完成再调用EndXxx方法来获得操作的结果。
循环查询IAsyncResult的IsComplete属性，操作完成后再调用EndXxx方法来获得操作返回的结果。
使用 AsyncCallback委托来指定操作完成时要调用的方法，在操作完成后调用的方法中调用EndXxx操作来获得异步操作的结果。

第一种方式：上面Main方法里面的写法，在BeginXXX后面写EndXXX。

第二种方式：WaitOne()

IAsyncResult iAsyncResult = asyncTask.BeginAsyncTask(2, 3, callback, "callbacking");

iAsyncResult.AsyncWaitHandle.WaitOne();//阻塞线程 WaitAll WaitAny

asyncTask.EndAsyncTask(iAsyncResult);

第三种方式：轮询

IAsyncResult iAsyncResult = asyncTask.BeginAsyncTask(2, 3, callback, "callbacking");

while (!iAsyncResult.IsCompleted)//边等待边操作

{

//等待中操作，进度条之类的

}

asyncTask.EndAsyncTask(iAsyncResult);

第四种方式：回调函数中执行(推荐)

static void Main(string[] args)

{

WydAsyncTask asyncTask = new WydAsyncTask();

IAsyncResult iAsyncResult = null;

AsyncCallback callback = ac =>

{

Console.WriteLine(ac.AsyncState.ToString());

int result = asyncTask.EndAsyncTask(iAsyncResult);//放到回调函数中

Console.WriteLine("异步Result=" + result.ToString());

};

iAsyncResult = asyncTask.BeginAsyncTask(2, 3, callback, "callbacking");

Console.ReadKey();

}

看到这，文章最开始的FileStream类中的BeginRead应该知道怎么实现的了吧。

实例

做过Winform的猿们肯定遇到过一个问题：多线程访问Winform的控件报错的问题，下面还原一下报错场景。

private void Form1_Load(object sender, EventArgs e)

{

Console.WriteLine("当前线程Id为：" + Thread.CurrentThread.ManagedThreadId);

Action action = () =>

{

Console.WriteLine("当前线程Id为：" + Thread.CurrentThread.ManagedThreadId);

lblShow.Text = DateTime.Now.ToString();

};

action.BeginInvoke(null, null);

}

打印结果：

当前线程Id为：1

当前线程Id为：3

窗体创建一个Label控件，在窗体Load方法里面通过委托的异步调用把当前时间赋值给Label控件，同时把当前线程唯一标识Id打印一下。调试运行一下，错误信息如下图：

错误信息：线程间操作无效，从不是创建控件”lblShow”的线程访问它。什么意思呢?

也就是说控件”lblShow”不允许不是创建它的线程访问，“lblShow”是主线程创建，Action委托通过线程池新开另一个线程去操作”lblShow”控件是不允许的。从上面的打印结果也能看出两者不是同一个线程。

如何去解决这个问题呢？

Winform程序遇到耗时任务时，让用户看着卡死的界面等待耗时任务不可取，我们可以通过另开一个线程去执行这个耗时任务，把主线程从耗时任务中解脱出来。

但是为了保证线程安全，框架不允许你新开的线程直接去操作控件，既然控件只能有主线程访问，所以只有一条路，”lblShow”控件的赋值重任还得落在主线程身上。

那还得从”lblShow”控件入手，看看微软给我们提供了什么？查看Control基类发现，每一个控件都有一个Invoke方法。方法构造如下：

// 摘要:

// 在拥有此控件的基础窗口句柄的线程上执行指定的委托。

// 参数:

// method:

// 包含要在控件的线程上下文中调用的方法的委托。

// 返回结果:

// 正在被调用的委托的返回值，或者如果委托没有返回值，则为 null。

[TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

public object Invoke(Delegate method);

此方法参数需要传入一个委托，那我们现在写写看：

private void Form1_Load(object sender, EventArgs e)

{

Console.WriteLine("当前线程Id为：" + Thread.CurrentThread.ManagedThreadId);

Action action = () =>

{

Console.WriteLine("当前线程Id为：" + Thread.CurrentThread.ManagedThreadId);

Action actionControl = UpdateControl;

lblShow.Invoke(actionControl); //控件的Invoke方法

};

action.BeginInvoke(null, null);

}

private void UpdateControl()

{

Console.WriteLine("当前线程Id为：" + Thread.CurrentThread.ManagedThreadId);

lblShow.Text = DateTime.Now.ToString();

}

打印结果为：

当前线程Id为：1

当前线程Id为：3

当前线程Id为：1

此时再去调试发现，上面的错误没有了，为什么呢？看一下打印结果，在UpdateControl方法里面的线程Id不就是主线程的Id吗，主线程(创建控件线程)去操作”lblShow”控件当然不会报上面的跨线程访问控件的错误信息了。所以可以看出调用控件的Invoke方法，作为参数的委托内部方法执行是由主线程来完成的。

上面的例子只是简单的打印下当前时间，并没有体会到耗时。下面我们加一个while(true)循环，让”lblShow”控件的时间动起来,这个循环代码写到哪里呢？写到UpdateControl里面？稍微想一下就可以否决了，这个方法里面是主线程在操作，里面加个死循环，那界面永远处于卡死状态。所以我们把while(true)语句加在新开辟的线程里面。代码如下：

private void Form1_Load(object sender, EventArgs e)

{

Action action = () =>

{

while (true)

{

Action actionControl = UpdateControl;

lblShow.Invoke(actionControl);

Thread.Sleep(1000);

}

};

action.BeginInvoke(null, null);

}

private void UpdateControl()

{

lblShow.Text = DateTime.Now.ToString();

}

再贴出一个Thread写法(Thread后续文章会讲)

private void Form1_Load(object sender, EventArgs e)

{

Thread thread = new Thread(new ThreadStart(() =>

{

while (true)

{

Action action = UpdateControl;

lblShow.BeginInvoke(action);

Thread.Sleep(1000);

}

}));

thread.IsBackground = true;

thread.Start();

}

private void UpdateControl()

{

lblShow.Text = DateTime.Now.ToString();

}

此时我们的时间就可以愉快的跑起来了，即不卡界面，也不存在跨线程操作控件的问题。

希望对大家有一点帮助，文中如有错误，烦劳您不吝指出，谢谢！

如果转载，请给出原文链接，谢谢！

微信支付宝

如果本文帮助到您，请随意打赏作者

C#异步操作(APM)

文章归档

分类目录