C#中的委托和事件(二)
引言
如果你看过了 c#中的委托和事件 一文，我想你对委托和事件已经有了一个基本的认识。但那些远不是委托和事件的全部内容，还有很多的地方没有涉及。本文将讨论委托和事件一些更为细节的问题，包括一些大家常问到的问题，以及事件访问器、异常处理、超时处理和异步方法调用等内容。
为什么要使用事件而不是委托变量？
在 c#中的委托和事件 中，我提出了两个为什么在类型中使用事件向外部提供方法注册，而不是直接使用委托变量的原因。主要是从封装性和易用性上去考虑，但是还漏掉了一点，事件应该由事件发布者触发，而不应该由客户端（客户程序）来触发。这句话是什么意思呢？请看下面的范例：
note：注 意这里术语的变化，当我们单独谈论事件，我们说发布者(publisher)、订阅者(subscriber)、客户端(client)。当我们讨论 observer模式，我们说主题(subject)和观察者(observer)。客户端通常是包含main()方法的program类。
class program {
static void main(string[] args) {
publishser pub = new publishser();
subscriber sub = new subscriber();
pub.numberchanged += new numberchangedeventhandler(sub.onnumberchanged);
pub.dosomething(); // 应该通过dosomething()来触发事件
pub.numberchanged(100); // 但可以被这样直接调用，对委托变量的不恰当使用
}
}
// 定义委托
public delegate void numberchangedeventhandler(int count);
// 定义事件发布者
public class publishser {
private int count;
public numberchangedeventhandler numberchanged; // 声明委托变量
//public event numberchangedeventhandler numberchanged; // 声明一个事件
public void dosomething() {
// 在这里完成一些工作 ...
if (numberchanged != null) { // 触发事件
count++;
numberchanged(count);
}
}
}
// 定义事件订阅者
public class subscriber {
public void onnumberchanged(int count) {
console.writeline("subscriber notified: count = {0}", count);
}
}
上 面代码定义了一个numberchangedeventhandler委托，然后我们创建了事件的发布者publisher和订阅者 subscriber。当使用委托变量时，客户端可以直接通过委托变量触发事件，也就是直接调用pub.numberchanged(100)，这将会影 响到所有注册了该委托的订阅者。而事件的本意应该为在事件发布者在其本身的某个行为中触发，比如说在方法dosomething()中满足某个条件后触发。通过添加event关键字来发布事件，事件发布者的封装性会更好，事 件仅仅是供其他类型订阅，而客户端不能直接触发事件（语句pub.numberchanged(100)无法通过编译），事件只能在事件发布者 publisher类的内部触发（比如在方法pub.dosomething()中），换言之，就是numberchanged(100)语句只能在 publisher内部被调用。
大家可以尝试一下，将委托变量的声明那行代码注释掉，然后取消下面事件声明的注释。此时程序是无法 编译的，当你使用了event关键字之后，直接在客户端触发事件这种行为，也就是直接调用pub.numberchanged(100)，是被禁止的。事 件只能通过调用dosomething()来触发。这样才是事件的本意，事件发布者的封装才会更好。
就好像如果我们要定义一个数字类型，我 们会使用int而不是使用object一样，给予对象过多的能力并不见得是一件好事，应该是越合适越好。尽管直接使用委托变量通常不会有什么问题，但它给 了客户端不应具有的能力，而使用事件，可以限制这一能力，更精确地对类型进行封装。
note：这里还有一个约定俗称的规定，就是订阅事件的方法的命名，通常为“on事件名”，比如这里的onnumberchanged。
为什么委托定义的返回值通常都为void？
尽 管并非必需，但是我们发现很多的委托定义返回值都为void，为什么呢？这是因为委托变量可以供多个订阅者注册，如果定义了返回值，那么多个订阅者的方法 都会向发布者返回数值，结果就是后面一个返回的方法值将前面的返回值覆盖掉了，因此，实际上只能获得最后一个方法调用的返回值。可以运行下面的代码测试一 下。除此以外，发布者和订阅者是松耦合的，发布者根本不关心谁订阅了它的事件、为什么要订阅，更别说订阅者的返回值了，所以返回订阅者的方法返回值大多数 情况下根本没有必要。
class program {
static void main(string[] args) {
publishser pub = new publishser();
subscriber1 sub1 = new subscriber1();
subscriber2 sub2 = new subscriber2();
subscriber3 sub3 = new subscriber3();
pub.numberchanged += new generaleventhandler(sub1.onnumberchanged);
pub.numberchanged += new generaleventhandler(sub2.onnumberchanged);
pub.numberchanged += new generaleventhandler(sub3.onnumberchanged);
pub.dosomething(); // 触发事件
}
}
// 定义委托
public delegate string generaleventhandler();
// 定义事件发布者
public class publishser {
public event generaleventhandler numberchanged; // 声明一个事件
public void dosomething() {
if (numberchanged != null) { // 触发事件
string rtn = numberchanged();
console.writeline(rtn); // 打印返回的字符串，输出为subscriber3
}
}
}
// 定义事件订阅者
public class subscriber1 {
public string onnumberchanged() {
return "subscriber1";
}
}
public class subscriber2 { /* 略，与上类似，返回subscriber2*/ }
public class subscriber3 { /* 略，与上类似，返回subscriber3*/ }
如果运行这段代码，得到的输出是subscriber3，可以看到，只得到了最后一个注册方法的返回值。
如何让事件只允许一个客户订阅？
少数情况下，比如像上面，为了避免发生“值覆盖”的情况（更多是在异步调用方法时，后面会讨论），我们可能想限制只允许一个客户端注册。此时怎么做呢？我们可以向下面这样，将事件声明为private的，然后提供两个方法来进行注册和取消注册：
// 定义事件发布者
public class publishser {
private event generaleventhandler numberchanged; // 声明一个私有事件
// 注册事件
public void register(generaleventhandler method) {
numberchanged = method;
}
// 取消注册
public void unregister(generaleventhandler method) {
numberchanged -= method;
}
public void dosomething() {
// 做某些其余的事情
if (numberchanged != null) { // 触发事件
string rtn = numberchanged();
console.writeline("return: {0}", rtn); // 打印返回的字符串，输出为subscriber3
}
}
}
note：注意上面，在unregister()中，没有进行任何判断就使用了numberchanged-=method语句。这是因为即使method方法没有进行过注册，此行语句也不会有任何问题，不会抛出异常，仅仅是不会产生任何效果而已。
注意在register()方法中，我们使用了赋值操作符“=”，而非“+=”，通过这种方式就避免了多个方法注册。上面的代码尽管可以完成我们的需要，但是此时大家还应该注意下面两点：
1、 将numberchanged声明为委托变量还是事件都无所谓了，因为它是私有的，即便将它声明为一个委托变量，客户端也看不到它，也就无法通过它来触发 事件、调用订阅者的方法。而只能通过register()和unregister()方法来注册和取消注册，通过调用dosomething()方法触发 事件（而不是numberchanged本身，这在前面已经讨论过了）。
2、我们还应该发现，这里采用的、对numberchanged委 托变量的访问模式和c#中的属性是多么类似啊？大家知道，在c#中通常一个属性对应一个类型成员，而在类型的外部对成员的操作全部通过属性来完成。尽管这 里对委托变量的处理是类似的效果，但却使用了两个方法来进行模拟，有没有办法像使用属性一样来完成上面的例子呢？答案是有的，c#中提供了一种叫事件访问 器（event accessor）的东西，它用来封装委托变量。如下面例子所示：
class program {
static void main(string[] args) {
publishser pub = new publishser();
subscriber1 sub1 = new subscriber1();
subscriber2 sub2 = new subscriber2();
pub.numberchanged -= sub1.onnumberchanged; // 不会有任何反应
pub.numberchanged += sub2.onnumberchanged; // 注册了sub2
pub.numberchanged += sub1.onnumberchanged; // sub1将sub2的覆盖掉了
pub.dosomething(); // 触发事件
}
}
// 定义委托
public delegate string generaleventhandler();
// 定义事件发布者
public class publishser {
// 声明一个委托变量
private generaleventhandler numberchanged;
// 事件访问器的定义
public event generaleventhandler numberchanged {
add {
numberchanged = value;
}
remove {
numberchanged -= value;
}
}
public void dosomething() {
// 做某些其他的事情
if (numberchanged != null) { // 通过委托变量触发事件
string rtn = numberchanged();
console.writeline("return: {0}", rtn); // 打印返回的字符串
}
}
}
// 定义事件订阅者
public class subscriber1 {
public string onnumberchanged() {
console.writeline("subscriber1 invoked!");
return "subscriber1";
}
}
public class subscriber2 {/* 与上类同，略 */}
public class subscriber3 {/* 与上类同，略 */}
上 面代码中类似属性的public event generaleventhandler numberchanged {add{...}remove{...}}语句便是事件访问器。使用了事件访问器以后，在dosomething方法中便只能通过 numberchanged委托变量来触发事件，而不能numberchanged事件访问器（注意它们的大小写不同）触发，它只用于注册和取消注册。下 面是代码输出：
subscriber1 invoked!
return: subscriber1
获得多个返回值与异常处理
现 在假设我们想要获得多个订阅者的返回值，以list<string>的形式返回，该如何做呢？我们应该记得委托定义在编译时会生成一个继承自 multicastdelegate的类，而这个multicastdelegate又继承自delegate，在delegate内部，维护了一个委托 链表，链表上的每一个元素，为一个只包含一个目标方法的委托对象。而通过delegate基类的getinvocationlist()静态方法，可以获 得这个委托链表。随后我们遍历这个链表，通过链表中的每个委托对象来调用方法，这样就可以分别获得每个方法的返回值：
class program4 {
static void main(string[] args) {
publishser pub = new publishser();
subscriber1 sub1 = new subscriber1();
subscriber2 sub2 = new subscriber2();
subscriber3 sub3 = new subscriber3();
pub.numberchanged += new demoeventhandler(sub1.onnumberchanged);
pub.numberchanged += new demoeventhandler(sub2.onnumberchanged);
pub.numberchanged += new demoeventhandler(sub3.onnumberchanged);
list<string> list = pub.dosomething(); //调用方法，在方法内触发事件
foreach (string str in list) {
console.writeline(str);
}
}
}
public delegate string demoeventhandler(int num);
// 定义事件发布者
public class publishser {
public event demoeventhandler numberchanged; // 声明一个事件
public list<string> dosomething() {
// 做某些其他的事
list<string> strlist = new list<string>();
if (numberchanged == null) return strlist;
// 获得委托数组
delegate[] delarray = numberchanged.getinvocationlist();
foreach (delegate del in delarray) {
// 进行一个向下转换
demoeventhandler method = (demoeventhandler)del;
strlist.add(method(100)); // 调用方法并获取返回值
}
return strlist;
}
}
// 定义事件订阅者
public class subscriber1 {
public string onnumberchanged(int num) {
console.writeline("subscriber1 invoked, number:{0}", num);
return "[subscriber1 returned]";
}
}
public class subscriber3 {与上面类同，略}
public class subscriber3 {与上面类同，略}
如果运行上面的代码，可以得到这样的输出：
subscriber1 invoked, number:100
subscriber2 invoked, number:100
subscriber3 invoked, number:100
[subscriber1 returned]
[subscriber2 returned]
[subscriber3 returned]
可 见我们获得了三个方法的返回值。而我们前面说过，很多情况下委托的定义都不包含返回值，所以上面介绍的方法似乎没有什么实际意义。其实通过这种方式来触发 事件最常见的情况应该是在异常处理中，因为很有可能在触发事件时，订阅者的方法会抛出异常，而这一异常会直接影响到发布者，使得发布者程序中止，而后面订 阅者的方法将不会被执行。因此我们需要加上异常处理，考虑下面一段程序：
class program5 {
static void main(string[] args) {
publisher pub = new publisher();
subscriber1 sub1 = new subscriber1();
subscriber2 sub2 = new subscriber2();
subscriber3 sub3 = new subscriber3();
pub.numberchanged += new demoeventhandler(sub1.onnumberchanged);
pub.numberchanged += new demoeventhandler(sub2.onnumberchanged);
pub.numberchanged += new demoeventhandler(sub3.onnumberchanged);
}
}
public class publisher {
public event eventhandler myevent;
public void dosomething() {
// 做某些其他的事情
if (myevent != null) {
try {
myevent(this, eventargs.empty);
} catch (exception e) {
console.writeline("exception: {0}", e.message);
}
}
}
}
public class subscriber1 {
public void onevent(object sender, eventargs e) {
console.writeline("subscriber1 invoked!");
}
}
public class subscriber2 {
public void onevent(object sender, eventargs e) {
throw new exception("subscriber2 failed");
}
}
public class subscriber3 {/* 与subsciber1类同，略*/}
注意到我们在subscriber2中抛出了异常，同时我们在publisher中使用了try/catch语句来处理异常。运行上面的代码，我们得到的结果是：
subscriber1 invoked!
exception: subscriber2 failed
可以看到，尽管我们捕获了异常，使得程序没有异常结束，但是却影响到了后面的订阅者，因为subscriber3也订阅了事件，但是却没有收到事件通知（它的方法没有被调用）。此时，我们可以采用上面的办法，先获得委托链表，然后在遍历链表的循环中处理异常，我们只需要修改一下dosomething方法就可以了：
public void dosomething() {
if (myevent != null) {
delegate[] delarray = myevent.getinvocationlist();
foreach (delegate del in delarray) {
eventhandler method = (eventhandler)del; // 强制转换为具体的委托类型
try {
method(this, eventargs.empty);
} catch (exception e) {
console.writeline("exception: {0}", e.message);
}
}
}
}
注 意到delegate是eventhandler的基类，所以为了触发事件，先要进行一个向下的强制转换，之后才能在其上触发事件，调用所有注册对象的方 法。除了使用这种方式以外，还有一种更灵活方式可以调用方法，它是定义在delegate基类中的dynamicinvoke()方法：
public object dynamicinvoke(params object[] args);
这可能是调用委托最通用的方法了，适用于所有类型的委托。它接受的参数为object[]，也就是说它可以将任意数量的任意类型作为参数，并返回单个object对象。上面的dosomething()方法也可以改写成下面这种通用形式：
public void dosomething() {
// 做某些其他的事情
if (myevent != null) {
delegate[] delarray = myevent.getinvocationlist();
foreach (delegate del in delarray) {
try {
// 使用dynamicinvoke方法触发事件
del.dynamicinvoke(this, eventargs.empty);
} catch (exception e) {
console.writeline("exception: {0}", e.message);
}
}
}
}
注 意现在在dosomething()方法中，我们取消了向具体委托类型的向下转换，现在没有了任何的基于特定委托类型的代码，而 dynamicinvoke又可以接受任何类型的参数，且返回一个object对象。所以我们完全可以将dosomething()方法抽象出来，使它成 为一个公共方法，然后供其他类来调用，我们将这个方法声明为静态的，然后定义在program类中：
// 触发某个事件，以列表形式返回所有方法的返回值
public static object[] fireevent(delegate del, params object[] args){
list<object> objlist = new list<object>();
if (del != null) {
delegate[] delarray = del.getinvocationlist();
foreach (delegate method in delarray) {
try {
// 使用dynamicinvoke方法触发事件
object obj = method.dynamicinvoke(args);
if (obj != null)
objlist.add(obj);
} catch { }
}
}
return objlist.toarray();
}
随后，我们在dosomething()中只要简单的调用一下这个方法就可以了：
public void dosomething() {
// 做某些其他的事情
program5.fireevent(myevent, this, eventargs.empty);
}
注 意fireevent()方法还可以返回一个object[]数组，这个数组包括了所有订阅者方法的返回值。而在上面的例子中，我没有演示如何获取并使用 这个数组，为了节省篇幅，这里也不再赘述了，在本文附带的代码中，有关于这部分的演示，有兴趣的朋友可以下载下来看看。
委托中订阅者方法超时的处理
订 阅者除了可以通过异常的方式来影响发布者以外，还可以通过另一种方式：超时。一般说超时，指的是方法的执行超过某个指定的时间，而这里我将含义扩展了一 下，凡是方法执行的时间比较长，我就认为它超时了，这个“比较长”是一个比较模糊的概念，2秒、3秒、5秒都可以视为超时。超时和异常的区别就是超时并不 会影响事件的正确触发和程序的正常运行，却会导致事件触发后需要很长才能够结束。在依次执行订阅者的方法这段期间内，客户端程序会被中断，什么也不能做。 因为当执行订阅者方法时（通过委托，相当于依次调用所有注册了的方法），当前线程会转去执行方法中的代码，调用方法的客户端会被中断，只有当方法执行完毕 并返回时，控制权才会回到客户端，从而继续执行下面的代码。我们来看一下下面一个例子：
class program6 {
static void main(string[] args) {
publisher pub = new publisher();
subscriber1 sub1 = new subscriber1();
subscriber2 sub2 = new subscriber2();
subscriber3 sub3 = new subscriber3();
pub.myevent += new eventhandler(sub1.onevent);
pub.myevent += new eventhandler(sub2.onevent);
pub.myevent += new eventhandler(sub3.onevent);
pub.dosomething(); // 触发事件
console.writeline(" control back to client!"); // 返回控制权
}
// 触发某个事件，以列表形式返回所有方法的返回值
public static object[] fireevent(delegate del, params object[] args) {
// 代码与上同，略
}
}
public class publisher {
public event eventhandler myevent;
public void dosomething() {
// 做某些其他的事情
console.writeline("dosomething invoked!");
program6.fireevent(myevent, this, eventargs.empty); //触发事件
}
}
public class subscriber1 {
public void onevent(object sender, eventargs e) {
thread.sleep(timespan.fromseconds(3));
console.writeline("waited for 3 seconds, subscriber1 invoked!");
}
}
public class subscriber2 {
public void onevent(object sender, eventargs e) {
console.writeline("subscriber2 immediately invoked!");
}
}
public class subscriber3 {
public void onevent(object sender, eventargs e) {
thread.sleep(timespan.fromseconds(2));
console.writeline("waited for 2 seconds, subscriber2 invoked!");
}
}
在 这段代码中，我们使用thread.sleep()静态方法模拟了方法超时的情况。其中subscriber1.onevent()需要三秒钟完 成，subscriber2.onevent()立即执行，subscriber3.onevent需要两秒完成。这段代码完全可以正常输出，也没有异常 抛出（如果有，也仅仅是该订阅者被忽略掉），下面是输出的情况：
dosomething invoked!
waited for 3 seconds, subscriber1 invoked!
subscriber2 immediately invoked!
waited for 2 seconds, subscriber2 invoked!
control back to client!
但 是这段程序在调用方法dosomething()、打印了“dosomething invoked”之后，触发了事件，随后必须等订阅者的三个方法全部执行完毕了之后，也就是大概5秒钟的时间，才能继续执行下面的语句，也就是打印 “control back to client”。而我们前面说过，很多情况下，尤其是远程调用的时候（比如说在remoting中），发布者和订阅者应该是完全的松耦合，发布者不关心谁 订阅了它、不关心订阅者的方法有什么返回值、不关心订阅者会不会抛出异常，当然也不关心订阅者需要多长时间才能完成订阅的方法，它只要在事件发生的那一瞬 间告知订阅者事件已经发生并将相关参数传给订阅者就可以了。然后它就应该继续执行它后面的动作，在本例中就是打印“control back to client！”。而订阅者不管失败或是超时都不应该影响到发布者，但在上面的例子中，发布者却不得不等待订阅者的方法执行完毕才能继续运行。
现 在我们来看下如何解决这个问题，先回顾一下之前我在c#中的委托和事件一文中提到的内容，我说过，委托的定义会生成继承自 multicastdelegate的完整的类，其中包含invoke()、begininvoke()和endinvoke()方法。当我们直接调用委 托时，实际上是调用了invoke()方法，它会中断调用它的客户端，然后在客户端线程上执行所有订阅者的方法（客户端无法继续执行后面代码），最后将控 制权返回客户端。注意到begininvoke()、endinvoke()方法，在.net中，异步执行的方法通常都会配对出现，并且以begin和 end作为方法的开头（最常见的可能就是stream类的beginread()和endread()方法了）。它们用于方法的异步执行，即是在调用 begininvoke()之后，客户端从线程池中抓取一个闲置线程，然后交由这个线程去执行订阅者的方法，而客户端线程则可以继续执行下面的代码。
begininvoke() 接受“动态”的参数个数和类型，为什么说“动态”的呢？因为它的参数是在编译时根据委托的定义动态生成的，其中前面参数的个数和类型与委托定义中接受的参 数个数和类型相同，最后两个参数分别是asynccallback和object类型，对于它们更具体的内容，可以参见下一节委托和方法的异步调用部分。 现在，我们仅需要对这两个参数传入null就可以了。另外还需要注意几点：
- 在委托类型上调用begininvoke()时，此委 托对象只能包含一个目标方法，所以对于多个订阅者注册的情况，必须使用getinvocationlist()获得所有委托对象，然后遍历它们，分别在其 上调用begininvoke()方法。如果直接在委托上调用begininvoke()，会抛出异常，提示“委托只能包含一个目标方法”。
- 如 果订阅者的方法抛出异常，.net会捕捉到它，但是只有在调用endinvoke()的时候，才会将异常重新抛出。而在本例中，我们不使用 endinvoke()（因为我们不关心订阅者的执行情况），所以我们无需处理异常，因为即使抛出异常，也是在另一个线程上，不会影响到客户端线程（客户 端甚至不知道订阅者发生了异常，这有时是好事有时是坏事）。
- begininvoke()方法属于委托定义所生成的类，它既不属于multicastdelegate也不属于delegate基类，所以无法继续使用可重用的fireevent()方法，我们需要进行一个向下转换，来获取到实际的委托类型。
现在我们修改一下上面的程序，使用异步调用来解决订阅者方法执行超时的情况：
class program6 {
static void main(string[] args) {
publisher pub = new publisher();
subscriber1 sub1 = new subscriber1();
subscriber2 sub2 = new subscriber2();
subscriber3 sub3 = new subscriber3();
pub.myevent += new eventhandler(sub1.onevent);
pub.myevent += new eventhandler(sub2.onevent);
pub.myevent += new eventhandler(sub3.onevent);
pub.dosomething(); // 触发事件
console.writeline("control back to client! "); // 返回控制权
console.writeline("press any thing to exit...");
console.readkey(); // 暂停客户程序，提供时间供订阅者完成方法
}
}
public class publisher {
public event eventhandler myevent;
public void dosomething() {
// 做某些其他的事情
console.writeline("dosomething invoked!");
if (myevent != null) {
delegate[] delarray = myevent.getinvocationlist();
foreach (delegate del in delarray) {
eventhandler method = (eventhandler)del;
method.begininvoke(null, eventargs.empty, null, null);
}
}
}
}
public class subscriber1 {
public void onevent(object sender, eventargs e) {
thread.sleep(timespan.fromseconds(3)); // 模拟耗时三秒才能完成方法
console.writeline("waited for 3 seconds, subscriber1 invoked!");
}
}
public class subscriber2 {
public void onevent(object sender, eventargs e) {
throw new exception("subsciber2 failed"); // 即使抛出异常也不会影响到客户端
//console.writeline("subscriber2 immediately invoked!");
}
}
public class subscriber3 {
public void onevent(object sender, eventargs e) {
thread.sleep(timespan.fromseconds(2)); // 模拟耗时两秒才能完成方法
console.writeline("waited for 2 seconds, subscriber3 invoked!");
}
}
运行上面的代码，会得到下面的输出：
dosomething invoked!
control back to client!
press any thing to exit...
waited for 2 seconds, subscriber3 invoked!
waited for 3 seconds, subscriber1 invoked!
需要注意代码输出中的几个变化：
- 我 们需要在客户端程序中调用console.readkey()方法来暂停客户端，以提供足够的时间来让异步方法去执行完代码，不然的话客户端的程序到此处 便会运行结束，程序会退出，不会看到任何订阅者方法的输出，因为它们根本没来得及执行完毕。原因是这样的：客户端所在的线程我们通常称为主线程，而执行订 阅者方法的线程来自线程池，属于后台线程(background thread），当主线程结束时，不论后台线程有没有结束，都会退出程序。（当然还有一种前台线程(foreground thread)，主线程结束后必须等前台线程也结束后程序才会退出，关于线程的讨论可以开辟另一个庞大的主题，这里就不讨论了）。
- 在打 印完“press any thing to exit...”之后，两个订阅者的方法会以2秒、1秒的间隔显示出来，且尽管我们先注册了subscirber1，但是却先执行了 subscriber3，这是因为执行它需要的时间更短。除此以外，注意到这两个方法是并行执行的，所以执行它们的总时间是最长的方法所需要的时间，也就 是3秒，而不是他们的累加5秒。
- 如同前面所提到的，尽管subscriber2抛出了异常，我们也没有针对异常进行处理，但是客户程序并没有察觉到，程序也没有因此而中断。
委托和方法的异步调用
通 常情况下，如果需要异步执行一个耗时的操作，我们会新起一个线程，然后让这个线程去执行代码。但是对于每一个异步调用都通过创建线程来进行操作显然会对性 能产生一定的影响，同时操作也相对繁琐一些。.net中可以通过委托进行方法的异步调用，就是说客户端在异步调用方法时，本身并不会因为方法的调用而中 断，而是从线程池中抓取一个线程去执行该方法，自身线程（主线程）在完成抓取线程这一过程之后，继续执行下面的代码，这样就实现了代码的并行执行。使用线 程池的好处就是避免了频繁进行异步调用时创建、销毁线程的开销。
如同上面所示，当我们在委托对象上调用begininvoke()时，便进行了一个异步的方法调用。上面的例子中是在事件的发布和订阅这一过程中使用了异步调用，而在事件发布者和订阅者之间往往是松耦合的，发布者通常不需要获得订阅者方法执行的情况；而当使用异步调用时，更多情况下是为了提升系统的性能，而并非专用于事件的发布和订阅这一编程模型。而在这种情况下使用异步编程时，就需要进行更多的控制，比如当异步执行方法的方法结束时通知客户端、返回异步执行方法的返回值等。本节就对begininvoke()方法、endinvoke()方法和其相关的iaysncresult做一个简单的介绍。
note：注意此处我已经不再使用发布者、订阅者这些术语，因为我们不再是讨论上面的事件模型，而是讨论在客户端程序中异步地调用方法，这里有一个思维的转变。
我们看这样一段代码，它演示了不使用异步调用的通常情况：
class program7 {
static void main(string[] args) {
console.writeline("client application started! ");
thread.currentthread.name = "main thread";
calculator cal = new calculator();
int result = cal.add(2, 5);
console.writeline("result: {0} ", result);
// 做某些其它的事情，模拟需要执行3秒钟
for (int i = 1; i <= 3; i++) {
thread.sleep(timespan.fromseconds(i));
console.writeline("{0}: client executed {1} second(s).",
thread.currentthread.name, i);
}
console.writeline(" press any key to exit...");
console.readkey();
}
}
public class calculator {
public int add(int x, int y) {
if (thread.currentthread.isthreadpoolthread) {
thread.currentthread.name = "pool thread";
}
console.writeline("method invoked!");
// 执行某些事情，模拟需要执行2秒钟
for (int i = 1; i <= 2; i++) {
thread.sleep(timespan.fromseconds(i));
console.writeline("{0}: add executed {1} second(s).",
thread.currentthread.name, i);
}
console.writeline("method complete!");
return x + y;
}
}
上面代码有几个关于对于线程的操作，如果不了解可以看一下下面的说明，如果你已经了解可以直接跳过：
- thread.sleep()， 它会让执行当前代码的线程暂停一段时间（如果你对线程的概念比较陌生，可以理解为使程序的执行暂停一段时间），以毫秒为单位，比如 thread.sleep(1000)，将会使线程暂停1秒钟。在上面我使用了它的重载方法，个人觉得使用 timespan.fromseconds(1)，可读性更好一些。
- thread.currentthread.name，通过这个属性可以设置、获取执行当前代码的线程的名称，值得注意的是这个属性只可以设置一次，如果设置两次，会抛出异常。
- thread.isthreadpoolthread，可以判断执行当前代码的线程是否为线程池中的线程。
通 过这几个方法和属性，有助于我们更好地调试异步调用方法。上面代码中除了加入了一些对线程的操作以外再没有什么特别之处。我们建了一个 calculator类，它只有一个add方法，我们模拟了这个方法需要执行2秒钟时间，并且每隔一秒进行一次输出。而在客户端程序中，我们使用 result变量保存了方法的返回值并进行了打印。随后，我们再次模拟了客户端程序接下来的操作需要执行2秒钟时间。运行这段程序，会产生下面的输出：
client application started!
method invoked!
main thread: add executed 1 second(s).
main thread: add executed 2 second(s).
method complete!
result: 7
main thread: client executed 1 second(s).
main thread: client executed 2 second(s).
main thread: client executed 3 second(s).
press any key to exit...
如果你确实执行了这段代码，会看到这些输出并不是一瞬间输出的，而是执行了大概5秒钟的时间，因为线程是串行执行的，所以在执行完add()方法之后才会继续客户端剩下的代码。
接 下来我们定义一个adddelegate委托，并使用begininvoke()方法来异步地调用它。在上面已经介绍过，begininvoke()除了 最后两个参数为asynccallback类型和object类型以外，前面的参数类型和个数与委托定义相同。另外begininvoke()方法返回了 一个实现了iasyncresult接口的对象（实际上就是一个asyncresult类型实例，注意这里iasyncresult和 aysncresult是不同的，它们均包含在.net framework中）。
asyncresult的用途有这么几个：传递参数，它 包含了对调用了begininvoke()的委托的引用；它还包含了begininvoke()的最后一个object类型的参数；它可以鉴别出是哪个方 法的哪一次调用，因为通过同一个委托变量可以对同一个方法调用多次。
endinvoke()方法接受iasyncresult类型的对象 （以及ref和out类型参数，这里不讨论了，对它们的处理和返回值类似），所以在调用begininvoke()之后，我们需要保留 iasyncresult，以便在调用endinvoke()时进行传递。这里最重要的就是endinvoke()方法的返回值，它就是方法的返回值。除 此以外，当客户端调用endinvoke()时，如果异步调用的方法没有执行完毕，则会中断当前线程而去等待该方法，只有当异步方法执行完毕后才会继续执 行后面的代码。所以在调用完begininvoke()后立即执行endinvoke()是没有任何意义的。我们通常在尽可能早的时候调用 begininvoke()，然后在需要方法的返回值的时候再去调用endinvoke()，或者是根据情况在晚些时候调用。说了这么多，我们现在看一下 使用异步调用改写后上面的代码吧：
public delegate int adddelegate(int x, int y);
class program8 {
static void main(string[] args) {
console.writeline("client application started! ");
thread.currentthread.name = "main thread";
calculator cal = new calculator();
adddelegate del = new adddelegate(cal.add);
iasyncresult asyncresult = del.begininvoke(2,5,null,null); // 异步调用方法
// 做某些其它的事情，模拟需要执行3秒钟
for (int i = 1; i <= 3; i++) {
thread.sleep(timespan.fromseconds(i));
console.writeline("{0}: client executed {1} second(s).",
thread.currentthread.name, i);
}
int rtn = del.endinvoke(asyncresult);
console.writeline("result: {0} ", rtn);
console.writeline(" press any key to exit...");
console.readkey();
}
}
public class calculator { /* 与上面同，略 */}
此时的输出为：
client application started!
method invoked!
main thread: client executed 1 second(s).
pool thread: add executed 1 second(s).
main thread: client executed 2 second(s).
pool thread: add executed 2 second(s).
method complete!
main thread: client executed 3 second(s).
result: 7
press any key to exit...
现 在执行完这段代码只需要3秒钟时间，两个for循环所产生的输出交替进行，这也说明了这两段代码并行执行的情况。可以看到add()方法是由线程池中的线 程在执行，因为thread.currentthread.isthreadpoolthread返回了true，同时我们对该线程命名为了pool thread。另外我们可以看到通过endinvoke()方法得到了返回值。
有时候，我们可能会将获得返回值的操作放到另一段代码或者客 户端去执行，而不是向上面那样直接写在begininvoke()的后面。比如说我们在program中新建一个方法getreturn()，此时可以通 过asyncresult的asyncdelegate获得del委托对象，然后再在其上调用endinvoke()方法，这也说明了 asyncresult可以唯一的获取到与它相关的调用了的方法（或者也可以理解成委托对象）。所以上面获取返回值的代码也可以改写成这样：
static int getreturn(iasyncresult asyncresult) {
asyncresult result = (asyncresult)asyncresult;
adddelegate del = (adddelegate)result.asyncdelegate;
int rtn = del.endinvoke(asyncresult);
return rtn;
}
然 后再将int rtn = del.endinvoke(asyncresult);语句改为int rtn = getreturn(asyncresult);。注意上面iasyncresult要转换为实际的类型asyncresult才能访问 asyncdelegate属性，因为它没有包含在iasyncresult接口的定义中。
begininvoke的另外两个参数分别是asynccallback和object类型，其中asynccallback是一个委托类型，它用于方法的回调，即是说当异步方法执行完毕时自动进行调用的方法。它的定义为：
public delegate void asynccallback(iasyncresult ar);
object类型用于传递任何你想要的数值，它可以通过iasyncresult的asyncstate属性获得。下面我们将获取方法返回值、打印返回值的操作放到了onaddcomplete()回调方法中：
public delegate int adddelegate(int x, int y);
class program9 {
static void main(string[] args) {
console.writeline("client application started! ");
thread.currentthread.name = "main thread";
calculator cal = new calculator();
adddelegate del = new adddelegate(cal.add);
string data = "any data you want to pass.";
asynccallback callback = new asynccallback(onaddcomplete);
del.begininvoke(2, 5, callback, data); // 异步调用方法
// 做某些其它的事情，模拟需要执行3秒钟
for (int i = 1; i <= 3; i++) {
thread.sleep(timespan.fromseconds(i));
console.writeline("{0}: client executed {1} second(s).",
thread.currentthread.name, i);
}
console.writeline(" press any key to exit...");
console.readkey();
}
static void onaddcomplete(iasyncresult asyncresult) {
asyncresult result = (asyncresult)asyncresult;
adddelegate del = (adddelegate)result.asyncdelegate;
string data = (string)asyncresult.asyncstate;
int rtn = del.endinvoke(asyncresult);
console.writeline("{0}: result, {1}; data: {2} ",
thread.currentthread.name, rtn, data);
}
}
public class calculator { /* 与上面同，略 */}
它产生的输出为：
client application started!
method invoked!
main thread: client executed 1 second(s).
pool thread: add executed 1 second(s).
main thread: client executed 2 second(s).
pool thread: add executed 2 second(s).
method complete!
pool thread: result, 7; data: any data you want to pass.
main thread: client executed 3 second(s).
press any key to exit...
这 里有几个值得注意的地方：1、我们在调用begininvoke()后不再需要保存iaysncresult了，因为aysnccallback委托将该 对象定义在了回调方法的参数列表中；2、我们在onaddcomplete()方法中获得了调用begininvoke()时最后一个参数传递的值，字符 串“any data you want to pass”；3、执行回调方法的线程并非客户端线程main thread，而是来自线程池中的线程pool thread。另外如前面所说，在调用endinvoke()时有可能会抛出异常，所以在应该将它放到try/catch块中，这里我就不再示范了。
总结
这篇文章是对我之前写的c#中的委托和事件的一个补充，大致分为了三个部分，第一部分讲述了几个容易让人产生困惑的问题：为什么使用事件而不是委托变量，为什么通常委托的定义都返回void；第二部分讲述了如何处理异常和超时；第三部分则讲述了通过委托实现异步方法的调用。
感谢阅读，希望这篇文章能给你带来帮助。
上一篇： 性能优化-内存泄漏