我要评论一、概念
.net 1.0提出了apm（asynchronous programming model）即异步编程模式。
.net的类库有以beginxxx和endxxx类似的方法，就是使用异步编程模型。
net framework很多类也实现了该模式，同时我们也可以自定义类来实现该模式，即在自定义的类中实现返回类型为iasyncresult接口的beginxxx方法和endxxx方法，另外委托类型也定义了begininvoke和endinvoke方法。
异步编程模型的本质
利用委托和线程池帮助我们实现异步编程模型模式。
该模式利用一个线程池线程去执行一个操作，在filestream类beginread方法中就是执行一个读取文件操作，该线程池线程会立即将控制权返回给调用线程，此时线程池线程在后台进行这个异步操作；
异步操作完成之后，通过回调函数来获取异步操作返回的结果，此时就是利用委托的机制。
1、beginxxx方法——开始执行异步操作介绍
当需要读取文件中的内容时，我们通常会采用filestream的同步方法read来读取，该同步方法的定义为：
// 从文件流中读取字节块并将该数据写入给定的字节数组中 public override int read(byte[] array, int offset, int count )
该同步方法会堵塞执行的线程。
可以通过beginread方法来实现异步编程，使读取操作不再堵塞ui线程。beginread方法代表异步执行read操作，并返回实现iasyncresult接口的对象，该对象存储着异步操作的信息。
// 开始异步读操作 // 前面的3个参数和同步方法代表的意思一样，这里就不说了，可以看到这里多出了2个参数 // usercallback代表当异步io操作完成时，你希望由一个线程池线程执行的方法,该方法必须匹配asynccallback委托 // stateobject代表你希望转发给回调方法的一个对象的引用，在回调方法中，可以查询iasyncresult接口的asyncstate属性来访问该对象 public override iasyncresult beginread(byte[] array, int offset, int numbytes, asynccallback usercallback, object stateobject)
从上面的代码中可以看出异步方法和同步方法的区别，如果你在使用该异步方法时，不希望异步操作完成后调用任何代码，你可以把usercallback参数设置为null。
2、endxxx方法——结束异步操作介绍
前面介绍完了beginxxx方法，我们看到所有beginxxx方法返回的都是实现了iasyncresult接口的一个对象，并不是对应的同步方法那样直接得到结果。
此时我们需要调用对应的endxxx方法来结束异步操作，并向该方法传递iasyncresult对象，endxxx方法的返回类型就是和同步方法一样的。例如，filestream的endread方法返回一个int32来代表从文件流中实际读取的字节数。
// 摘要: 等待挂起的异步读取完成。 // asyncresult:对要完成的挂起异步请求的引用。 // 返回结果: 从流中读取的字节数. public virtual int endread(iasyncresult asyncresult);
对于访问异步操作的结果，apm的首选方式是：
使用 asynccallback委托来指定操作完成时要调用的方法，在操作完成后调用的方法中调用endxxx操作来获得异步操作的结果。
二、apm示例：
代码：
private static void main(string[] args)
{
string downurl = "http://download.microsoft.com/download/5/b/9/5b924336-aa5d-4903-95a0-56c6336e32c9/tap.docx";
downloadfilesync(downurl); //同步下载文件，在下载操作完成之后我们才可以看到"start download file......." 消息显示
downloadfileasync(downurl); //异步下载文件，在下载操作完成之前我们就可以看到"start download file......." 消息显示
console.writeline("开始下载文件.........");
console.readline();
}
//同步下载文件
private static void downloadfilesync(string url)
{
requeststate req = new requeststate(); // 创建一个 requeststate 实例
try
{
httpwebrequest myhttpwebrequest = (httpwebrequest)webrequest.create(url); // 初始化一个 httpwebrequest 对象
req.request = myhttpwebrequest; // 指派 httpwebrequest实例到requeststate的request字段.
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("\n此文件的长度是: {0}", req.filestream.length);
console.writeline("下载完成，下载路径是: {0}", req.savepath);
}
catch (exception e)
{
console.writeline("错误信息:{0}", e.message);
}
finally
{
req.response.close();
req.filestream.close();
}
}
//异步下载文件
private static void downloadfileasync(string url)
{
try
{
httpwebrequest myhttpwebrequest = (httpwebrequest)webrequest.create(url);
requeststate req = new requeststate();
req.request = myhttpwebrequest;
myhttpwebrequest.begingetresponse(new asynccallback(responsecallback), req);
}
catch (exception e)
{
console.writeline("错误信息:{0}", e.message);
}
}
//每个异步操作完成时，将调用下面的方法
private static void responsecallback(iasyncresult callbackresult)
{
requeststate req = (requeststate)callbackresult.asyncstate; // 获取 requeststate 对象
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 req = (requeststate)asyncresult.asyncstate; // 获取 requeststate 对象
stream responserstream = req.streamresponse; //从requeststate对象中获取 response stream
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("\n此文件的长度是: {0}", req.filestream.length);
console.writeline("下载完成，下载路径是: {0}", req.savepath);
req.response.close();
req.filestream.close();
}
}
catch (exception e)
{
console.writeline("错误信息:{0}", e.message);
}
}
//存储请求的状态类
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);
}
}运行结果：
使用同步方法下载文件的运行结果为：（从运行结果也可以看出，调用的是同步方法时，此时会堵塞主线程，直到文件的下载操作被完成之后主线程才继续执行后面的代码)
使用apm异步编程：运行结果为（从运行结果也可以看出，在主线程中调用 downloadfileasync(downurl)方法时，downloadfileasync(downurl)方法中的req.begingetresponse调用被没有阻塞调用线程(即主线程)，而是立即返回到主线程，是主线程后面的代码可以立即执行）
三、委托实例的异步调用（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(this.txburl.text.trim(), getresult, null);
}
// 异步操作完成时执行的方法
private void getresult(iasyncresult result)
{
asyncmethodcaller caller = (asyncmethodcaller)((asyncresult)result).asyncdelegate;// 或者(asyncmethodcaller)result.asyncstate;
string returnstring = caller.endinvoke(result); // 调用endinvoke去等待异步调用完成并且获得返回值,如果异步调用尚未完成，则 endinvoke 会一直阻止调用线程，直到异步调用完成
// 然后invoke方法来使更新gui操作方法由gui 线程去执行
this.invoke(new methodinvoker(() =>
{
rtbstate.text = returnstring;
btndownload.enabled = true;
}));
}运行的结果为：
上例子中使用了控件的invoke方式进行异步回调访问控件的方法，其背后是通过获得gui线程的同步上文对象synchronizationcontext，然后同步调用同步上下文对象的post方法把要调用的方法交给gui线程去处理。
四、task实例
假如现在有这样的一个需求，我们需要从3个txt文件中读取字符，然后进行倒序，前提是不能阻塞主线程。
如果不用task的话我可能会用工作线程去监视一个bool变量来判断文件是否全部读取完毕，然后再进行倒序，我也说了，相对task来说还是比较麻烦的，这里我就用task来实现。
private 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();
}
//异步读取
private 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);
}到此这篇关于.net1.0异步编程模型(apm)的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持代码网。
发表评论