添加委托和事件教学文档

.vuepress/config.js

@@ -75,7 +75,11 @@ module.exports = {
           {title: '字符串', path: '/csharp/06.string'},
           {title: '内存对象', path: '/csharp/07.memoryobject'},
           {title: '数据库操作', path: '/csharp/08.dbop'},
-          {title: '委托与事件', path: '/csharp/09.event'},
+          {title: '委托与事件',path: '/csharp/09.delege&event', collapsable:true,children:[
+            {title: '委托', path: '/csharp/091.delege'},
+            {title: '事件', path: '/csharp/092.event'},
+            {title: '委托事件进阶', path: '/csharp/093.advanced'},
+          ]},
           {title: '泛型', path: '/csharp/10.genericity'},
           {title: 'Linq', path: '/csharp/11.linq'},
           {title: '语法糖', path: '/csharp/12.sugar'},

csharp/09.delege&event.md

@@ -0,0 +1,2 @@
+# 委托与事件
+委托和事件在 .NET Framework 中的应用非常广泛，然而，较好地理解委托和事件对很多接触 C# 时间不长的人来说并不容易。它们就像是一道槛儿，过了这个槛的人，觉得真是太容易了，而没有过去的人每次见到委托和事件就觉得心里堵得慌，浑身不自在。我将由浅入深地讲述什么是委托、为什么要使用委托、事件的由来、.NET Framework 中的委托和事件、委托中方法异常和超时的处理、委托与异步编程、委托和事件对Observer 设计模式的意义，对它们的编译代码也做了讨论。

csharp/09.event.md

@@ -1 +0,0 @@
-# 委托与事件

csharp/091.delege.md

@@ -0,0 +1,255 @@
+# 委托
+
+## 什么是委托
+
+C#的委托类似于C或C++中<font color="red">函数的指针</font>，**委托**是一种存着对某个方法引用的引用类型变量，引用在运行时可以被改变。或者可以这么理解，我们将委托理解为**方法的抽象**，也就是方法的模板，至于这个方法是怎么样的，就由方法自己去实现。
+
+我们知道接口的最大好处就是可以实现多态，同理，**委托**是可以实现方法的多态，当我们想调用某个具体方法的时候，我们不直接调用这个方法，而是去调用这个委托。当然，我们必须在具体方法和委托之间建立某种关联。
+
+委托常被用于事件和回调方法。所有委托都派生自**System.Delegate**类。
+## 定义一个委托
+
+委托使用关键字`delegate`来定义，语法如下：
+
+```csharp
+delegate <return type> <delegate-name> (params)
+```
+例如我们定义一个具体的委托：
+```csharp
+public delegate void Test();
+```
+这就定义了一个没有返回值和参数的委托，并且语法根定义抽象方法很类似，只不过多了一个**delegate**关键字。
+
+<font color="red">**注意**</font>
+
+- 委托的定义一般放到类的外部，因为大多数委托将会被频繁调用。如果定义到类的内部，则只有本类可以直接使用该委托，其他的必须通过类成员才能调用。
+
+- 如果委托定义到类外部，一般定义为public，便于外部调用。
+
+- 定义到类内部时，不能在方法中定义委托。
+
+接下来，我们开始讲如何使用委托。
+## 方法作为方法参数
+
+我们先不管这个标题怎么理解，先看下面的示例代码，它们的作用就是在屏幕上输出一段话：
+
+```csharp
+namespace Test
+{
+    class Program
+    {
+        public static void Hello(string name)
+        {
+            EnglishHello(name);
+        }
+
+        public static void EnglishHello(string name)
+        {
+            Console.WriteLine("Hello,{0}",name);
+        }
+
+        static void Main(string[] args)
+        {
+            Hello("Liker") ;
+        }
+    }
+}
+```
+
+`Hello` 用于向某人问好，当我们传递代表某人姓名的 name 参数，比如说“Jone”进去的时候，在这个方法中，将调用 `EnglishHello`方法，再次传递 name 参数，`EnglishHello`则用于向屏幕输出 “Hello, Jone”。
+
+现在假设这个程序需要进行全球化，哎呀，不好了，我是中国人，我不明白“Hello”是什么意思，怎么办呢？好吧，我们再加个中文版的问候方法：
+
+```csharp
+public static void ChineseHello(string name)
+{
+	Console.WriteLine("你好，{0}",name);
+}
+```
+
+这时候，`Hello`也需要改一改了，不然如何判断到底用哪个版本的 问候方法合适呢？在进行这个之前，我们最好再定义一个枚举作为判断的依据：
+
+```csharp
+public enum Language
+{
+    English, Chinese
+}
+ 
+public static void Hello(string name, Language lang)
+{
+    switch (lang)
+    {
+        case Language.English:
+            EnglishHello(name);
+            break;
+        case Language.Chinese:
+            ChineseHello(name);
+            break;
+    }
+}
+```
+
+**OK，尽管这样解决了问题，但我不说大家也很容易想到，这个解决方案的可扩展性很差，如果日后我们需要再添加韩文版、日文版，就不得不反复修改枚举和GreetPeople() 方法，以适应新的需求。**
+
+在考虑新的解决方案之前，我们先看看 `Hello`的方法签名：
+
+```csharp
+public static void Hello(string name, Language lang);
+```
+
+我们想，假如 `Hello()` 方法可以接受一个参数变量，这个变量可以代表另一个方法，当我们给这个变量赋值 **EnglishHello** 的时候，它代表着 `EnglishHello () `这个方法；当我们给它赋值**ChineseHello** 的时候，它又代表着 `ChineseHello () `法。我们将这个参数变量命名为 **MakeHello**，那么不是可以如同给 name 赋值时一样，在调用` Hello()`方法的时候，给这个**MakeHello**参数也赋上值么(**EnglishHello** 或者**ChineseHello** 等)？然后，我们在方法体内，也可以像使用别的参数一样使用**MakeHello**。但是，由于 **MakeHello**代表着一个方法，它的使用方式应该和它被赋的方法(比如**ChineseHello** )是一样的，比如：`MakeGreeting(name);`
+
+好了，有了思路了，我们现在就来改改`GreetPeople()`方法，那么它应该是这个样子了：
+
+```csharp
+public void Hello(string name, xxx MakeHello)
+{
+    MakeHello(name);
+}
+```
+
+注意到 xxx，这个位置通常放置的应该是参数的类型，但到目前为止，我们仅仅是想到应该有个可以代表方法的参数，并按这个思路去改写 `Hello`方法，现在就出现了一个大问题：这个代表着方法的 MakeHello参数应该是什么类型？
+
+**说明：**这里已不再需要枚举了，因为在给MakeHello赋值的时候动态地决定使用哪个方法，是 `ChineseHello`还是` EnglishHello`，而在这个两个方法内部，已经对使用“Hello”还是“你好”作了区分。
+
+聪明的你应该已经想到了，现在是委托该出场的时候了，但讲述委托之前，我们再看看MakeHello参数所能代表的 `ChineseHello`和` EnglishHello`方法的签名：
+
+```csharp
+public void EnglishHello(string name)
+public void ChineseHello(string name)
+```
+
+如同 name 可以接受 String 类型的“true”和“1”，但不能接受bool 类型的true 和int 类型的1 一样，MakeHello的参数类型定义应该能够确定 MakeHello可以代表的方法种类，再进一步讲，就是 MakeHello可以代表的方法的参数类型和返回类型。
+
+于是，委托出现了：它定义了 MakeHello参数所能代表的方法的种类，也就是 MakeHello参数的类型。
+
+本例中委托的定义：
+
+```csharp
+public delegate void HelloDelegate(string name);
+```
+
+与上面 `EnglishHello()` 方法的签名对比一下，除了加入了delegate 关键字以外，其余的是不是完全一样？现在，让我们再次改动`Hello()`方法，如下所示：
+
+```csharp
+public delegate void HelloDelegate(string name);
+public static void Hello(string name, HelloDelegate MakeHello)
+{
+    MakeHello(name);
+}
+```
+
+如你所见，委托 HelloDelegate出现的位置与 string 相同，string 是一个类型，那么 HelloDelegate应该也是一个类型，或者叫类(Class)。但是委托的声明方式和类却完全不同，这是怎么一回事？实际上，委托在编译的时候确实会编译成类。因为 Delegate 是一个类，所以在任何可以声明类的地方都可以声明委托。更多的内容将在下面讲述，现在，请看看这个范例的完整代码：
+
+```csharp
+public delegate void HelloDelegate(string name);
+ 
+class Test
+{
+    public static void EnglishHello(string name)
+    {
+        Console.WriteLine("Hello,{0} ", name);
+    }
+ 
+    public static void ChineseHello(string name)
+    {
+        Console.WriteLine("你好,{0}", name);
+    }
+ 
+    public static void Hello(string name, HelloDelegate MakeHello)
+    {
+        MakeHello(name);
+    }
+ 
+    static void Main(string[] args)
+    {
+        Hello("Liker", EnglishHello);
+        Hello("李志中", ChineseHello);
+        Console.ReadLine();
+    }
+}
+```
+
+我们现在对委托做一个总结：委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If … Else(Switch)语句，同时使得程序具有更好的可扩展性。
+
+## 将方法绑定到委托
+
+看到这里，是不是有那么点如梦初醒的感觉？于是，你是不是在想：在上面的例子中，我不一定要直接在 Hello() 方法中给 name 参数赋值，我可以像这样使用变量：
+
+```csharp
+static void Main(string[] args)
+{
+    Hello("Liker", EnglishHello);
+    Hello("李志中", ChineseHello);
+    Console.ReadLine();
+}
+```
+
+而既然委托 HelloDelegate和类型 string 的地位一样，都是定义了一种参数类型，那么，我是不是也可以这么使用委托？
+
+```csharp
+static void Main(string[] args)
+{
+    HelloDelegate delegate1, delegate2;
+    delegate1 = EnglishHello;
+    delegate2 = ChineseHello;
+    Hello("Liker", delegate1);
+    Hello("李志中", delegate2);
+    Console.ReadLine();
+}
+```
+
+如你所料，这样是没有问题的，程序一如预料的那样输出。这里，我想说的是委托不同于 string 的一个特性：**可以将多个方法赋给同一个委托，或者叫将多个方法绑定到同一个委托，当调用这个委托的时候，将依次调用其所绑定的方法。**在这个例子中，语法如下：
+
+```csharp
+static void Main(string[] args)
+{
+    HelloDelegate delegate1;
+    delegate1 = EnglishHello; 
+    delegate1 += ChineseHello;
+    Hello("Liker", delegate1);
+    Console.ReadLine();
+}
+```
+
+实际上，我们可以也可以绕过`Hello`方法，通过委托来直接调用`EnglishHello` 和`ChineseHello`：
+
+```csharp
+static void Main(string[] args)
+{
+    HelloDelegate delegate1;
+    delegate1 = EnglishHello;
+    delegate1 += ChineseHello; 
+    delegate1("Liker");
+    Console.ReadLine();
+}
+```
+
+<font color="red">**注意**</font>：这在本例中是没有问题的，但回头看下上面 `Hello() `的定义，在它之中可以做一些对于` EnglshihHello` 和 `ChineseHello` 来说都需要进行的工作，为了简便我做了省略。
+
+**注意这里，第一次用的“=”，是赋值的语法；第二次，用的是“+=”，是绑定的语法。如果第一次就使用“+=”，将出现“使用了未赋值的局部变量”的编译错误。**我们也可以使用下面的代码来这样简化这一过程：
+
+```csharp
+HelloDelegate delegate1 = new HelloDelegate(EnglishHello);
+delegate1 += ChineseHello;
+```
+
+既然给委托可以绑定一个方法，那么也应该有办法取消对方法的绑定，很容易想到，这个语法是“-=”：
+
+```csharp
+static void Main(string[] args)
+{
+    HelloDelegate delegate1 = new HelloDelegate(EnglishHello);
+    delegate1 += ChineseHello;
+    Hello("Liker", delegate1);
+    Console.WriteLine();
+ 
+    delegate1 -= EnglishHello;
+    Hello("李志中", delegate1);
+    Console.ReadLine();
+}
+```
+
+**让我们再次对委托作个总结：**
+
+**使用委托可以将多个方法绑定到同一个委托变量，当调用此变量时(这里用“调用”这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。**

csharp/092.event.md

@@ -0,0 +1,216 @@
+# 事件
+## 什么是事件
+事件（Event） 基本上说是一个用户操作，如按键、点击、鼠标移动等等，或者是一些提示信息，如系统生成的通知。应用程序需要在事件发生时响应事件。例如，中断。
+
+C# 中使用事件机制实现线程间的通信。
+
+下面我们将一起探讨下事件的由来。
+## 更好的封装性
+我们继续思考上面的程序：上面的三个方法都定义在 `Programe` 类中，这样做是为了理解的方便，实际应用中，通常都是 `Hello` 在一个类中，`ChineseHello`和 `EnglishHello` 在另外的类中。现在你已经对委托有了初步了解，是时候对上面的例子做个改进了。假设我们将 `Hello()` 放在一个叫 `HelloManager` 的类中，那么新程序应该是这个样子的：
+```csharp
+
+namespace Delegate
+{
+    public delegate void HelloDelegate(string name);
+ 
+    public class HelloManager
+    {
+        public void Hello(string name, HelloDelegate MakeHello)
+        {
+            MakeHello(name);
+        }
+    }
+ 
+    class Program
+    {
+        private static void EnglishHello(string name)
+        {
+            Console.WriteLine("Hello, " + name);
+        }
+ 
+        private static void ChineseHello(string name)
+        {
+            Console.WriteLine("你好, " + name);
+        }
+ 
+        static void Main(string[] args)
+        {
+            HelloManager gm = new HelloManager();
+            gm.GreetPeople("Liker", EnglishHello);
+            gm.GreetPeople("李志中", ChineseHello);
+        }
+    }
+}
+```
+我们运行这段代码，嗯，没有任何问题。
+
+现在，假设我们需要使用上一节学到的知识，将多个方法绑定到同一个委托变量，该如何做呢？让我们再次改写代码：
+```csharp
+static void Main(string[] args)
+{
+    HelloManager gm = new HelloManager();
+    HelloDelegate delegate1;
+    delegate1 = EnglishHello;
+    delegate1 += ChineseHello;
+    gm.GreetPeople("Liker", delegate1);
+}
+```
+输出结果：
+```shell
+Hello, Liker
+你好, Liker
+```
+
+到了这里，我们不禁想到：**面向对象设计，讲究的是对象的封装，既然可以声明委托类型的变量(在上例中是delegate1)，我们何不将这个变量封装到 `GreetManager` 类中？在这个类的客户端中使用不是更方便么**，于是，我们改写`GreetManager` 类，像这样：
+```csharp
+public class HelloManager
+{
+    /// <summary>
+    /// 在 HelloManager 类的内部声明 delegate1 变量
+    /// </summary>
+    public HelloDelegate delegate1;
+ 
+    public void GreetPeople(string name, HelloDelegate MakeHello)
+    {
+        MakeHello(name);
+    }
+}
+```
+现在，我们可以这样使用这个委托变量：
+```csharp
+static void Main(string[] args)
+{
+    HelloManager gm = new HelloManager();
+    gm.delegate1 = EnglishHello;
+    gm.delegate1 += ChineseHello;
+    gm.GreetPeople("Liker", gm.delegate1);
+}
+```
+输出结果也没有问题。
+
+**尽管这样做没有任何问题，但我们发现这条语句很奇怪。在调用`gm.GreetPeople` 方法的时候，再次传递了gm 的delegate1 字段**, 既然如此，我们何不修改 `HelloManager` 类成这样：
+```csharp
+public class HelloManager
+ {
+     /// <summary>
+     /// 在 HelloManager 类的内部声明 delegate1 变量
+     /// </summary>
+     public HelloDelegate delegate1;
+ 
+     public void Hello(string name)
+     {
+         if (delegate1 != null) // 如果有方法注册委托变量
+         { 
+             delegate1(name); // 通过委托调用方法
+         }
+     }
+ }
+```
+在客户端，调用看上去更简洁一些：
+```csharp
+static void Main(string[] args)
+{
+    HelloManager gm = new HelloManager();
+    gm.delegate1 = EnglishHello;
+    gm.delegate1 += ChineseHello;
+    gm.GreetPeople("Liker"); //注意，这次不需要再传递 delegate1 变量
+}
+```
+
+尽管这样达到了我们要的效果，但是还是存在着问题：在这里，delegate1 和我们平时用的string 类型的变量没有什么分别，而我们知道，并不是所有的字段都应该声明成public，合适的做法是应该public 的时候public，应该private 的时候private。
+
+我们先看看如果把 delegate1 声明为 private 会怎样？结果就是：这简直就是在搞笑。因为声明委托的目的就是为了把它暴露在类的客户端进行方法的注册，你把它声明为 private 了，客户端对它根本就不可见，那它还有什么用？
+
+再看看把delegate1 声明为 public 会怎样？结果就是：在客户端可以对它进行随意的赋值等操作，严重破坏对象的封装性。
+
+最后，第一个方法注册用“=”，是赋值语法，因为要进行实例化，第二个方法注册则用的是“+=”。但是，不管是赋值还是注册，都是将方法绑定到委托上，除了调用时先后顺序不同，再没有任何的分别，这样不是让人觉得很别扭么？
+
+现在我们想想，如果delegate1 不是一个委托类型，而是一个string 类型，你会怎么做？答案是使用属性对字段进行封装。
+
+**于是，Event 出场了，它封装了委托类型的变量。我们改写HelloManager 类，它变成了这个样子**：
+```csharp
+public class HelloManager
+{
+    //这一次我们在这里声明一个事件
+    public event HelloDelegate MakeHello;
+ 
+    public void Hello(string name)
+    {
+        MakeHello(name);
+    }
+}
+```
+很容易注意到：`MakeGreet` 事件的声明与之前委托变量 delegate1 的声明唯一的区别是多了一个 `event` 关键字。看到这里，在结合上面的讲解，你应该明白到：事件其实没什么不好理解的，声明一个事件不过类似于声明一个进行了封装的委托类型的变量而已。
+
+为了证明上面的推论，如果我们像下面这样改写Main 方法：
+```csharp
+static void Main(string[] args)
+{
+    HelloManager gm = new HelloManager();
+    gm.MakeGreet = EnglishHello; // 编译错误1
+    gm.MakeGreet += ChineseHello;
+    gm.GreetPeople("Liker");
+}
+```
+会报编译错误的提示信息。
+## 限制类型能力
+使用事件不仅能获得比委托更好的封装性，还能限制含有事件的类型的能力。这是什么意思呢？它的意思是说：事件应该由**事件发布者**触发，而不应该由事件的**客户程序**来触发。请看下面的范例：
+```csharp
+using System;
+ 
+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); // 但可以被这样直接调用，对委托变量的不恰当使用
+    }
+}
+ 
+/// <summary>
+/// 定义委托
+/// </summary>
+/// <param name="count"></param>
+public delegate void NumberChangedEventHandler(int count);
+ 
+/// <summary>
+/// 定义事件发布者
+/// </summary>
+public class Publishser
+{
+    private int count;
+ 
+    public NumberChangedEventHandler NumberChanged; // 声明委托变量
+ 
+    //public event NumberChangedEventHandler NumberChanged; // 声明一个事件
+ 
+    public void DoSomething()
+    {
+        // 在这里完成一些工作 ...
+ 
+        if (NumberChanged != null) // 触发事件
+        { 
+            count++;
+            NumberChanged(count);
+        }
+    }
+}
+ 
+/// <summary>
+/// 定义事件订阅者
+/// </summary>
+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` 一样，给予对象过多的能力并不见得是一件好事，应该是越合适越好。尽管直接使用委托变量通常不会有什么问题，但它给了客户端不应具有的能力，而使用事件，可以限制这一能力，更精确地对类型进行封装。

csharp/093.advanced.md

@@ -0,0 +1,307 @@
+# 委托事件进阶
+## 为什么委托定义的返回值通常都为void 
+尽管并非必需，但是我们发现很多的委托定义返回值都为 void，为什么呢？这是因为委托变量可以供多个订阅者注册，如果定义了返回值，那么多个订阅者的方法都会向发布者返回数值，结果就是后面一个返回的方法值将前面的返回值覆盖掉了，因此，实际上只能获得最后一个方法调用的返回值。可以运行下面的代码测试一下。除此以外，发布者和订阅者是松耦合的，发布者根本不关心谁订阅了它的事件、为什么要订阅，更别说订阅者的返回值了，所以返回订阅者的方法返回值大多数情况下根本没有必要。
+## 如何让事件只允许一个客户订阅
+少数情况下，比如像上面，为了避免发生“值覆盖”的情况（更多是在异步调用方法时，后面会讨论），我们可能想限制只允许一个客户端注册。此时怎么做呢？我们可以向下面这样，将事件声明为private 的，然后提供两个方法来进行注册和取消注册：
+```csharp
+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
+        }
+    }
+}
+```
+
+**注意上面，在UnRegister()中，没有进行任何判断就使用了NumberChanged -= method 语句。这是因为即使method 方法没有进行过注册，此行语句也不会有任何问题，不会抛出异常，仅仅是不会产生任何效果而已。**
+
+**注意在Register()方法中，我们使用了赋值操作符“=”，而非“+=”，通过这种方式就避免了多个方法注册。**
+
+## 委托和方法的异步调用
+通常情况下，如果需要异步执行一个耗时的操作，我们会新起一个线程，然后让这个线程去执行代码。但是对于每一个异步调用都通过创建线程来进行操作显然会对性能产生一定的影响，同时操作也相对繁琐一些。.NET 中可以通过委托进行方法的异步调用，就是说客户端在异步调用方法时，本身并不会因为方法的调用而中断，而是从线程池中抓取一个线程去执行该方法，自身线程（主线程）在完成抓取线程这一过程之后，继续执行下面的代码，这样就实现了代码的并行执行。使用线程池的好处就是避免了频繁进行异步调用时创建、销毁线程的开销。当我们在委托对象上调用`BeginInvoke()`时，便进行了一个异步的方法调用。
+
+事件发布者和订阅者之间往往是松耦合的，发布者通常不需要获得订阅者方法执行的情况；而当使用异步调用时，更多情况下是为了提升系统的性能，而并非专用于事件的发布和订阅这一编程模型。而在这种情况下使用异步编程时，就需要进行更多的控制，比如当异步执行方法的方法结束时通知客户端、返回异步执行方法的返回值等。本节就对 `BeginInvoke()` 方法、`EndInvoke()` 方法和其相关的 `IAysncResult` 做一个简单的介绍。
+
+我们先看这样一段代码，它演示了不使用异步调用的通常情况：
+```csharp
+class Program7
+{
+    static void Main(string[] args)
+    {
+        Console.WriteLine("Client application started!\n");
+        Thread.CurrentThread.Name = "Main Thread";
+        Calculator cal = new Calculator();
+        int result = cal.Add(2, 5);
+        Console.WriteLine("Result: {0}\n", 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("\nPress any key to exit...");
+        Console.ReadLine();
+    }
+}
+ 
+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;
+    }
+}
+```
+上面代码有几个关于对于线程的操作，如果不了解可以看一下下面的说明，如果你已经了解可以直接跳过：
+
+1. `Thread.Sleep()`，它会让执行当前代码的线程暂停一段时间（如果你对线程的概念比较陌生，可以理解为使程序的执行暂停一段时间），以毫秒为单位，比如`Thread.Sleep(1000)`，将会使线程暂停1 秒钟。在上面我使用了它的重载方法，个人觉得使用`TimeSpan.FromSeconds(1)`，可读性更好一些。
+
+2. `Thread.CurrentThread.Name`，通过这个属性可以设置、获取执行当前代码的线程的名称，值得注意的是这个属性只可以设置一次，如果设置两次，会抛出异常。
+
+3. `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()`，或者是根据情况在晚些时候调用。说了这么多，我们现在看一下使用异步调用改写后上面的代码吧：
+```csharp
+using System.Threading;
+using System;
+ 
+public delegate int AddDelegate(int x, int y);
+class Program8
+{
+    static void Main(string[] args)
+    {
+        Console.WriteLine("Client application started!\n");
+        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}\n", rtn);
+        Console.WriteLine("\nPress any key to exit...");
+        Console.ReadLine();
+    }
+}
+ 
+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;
+    }
+}
+```
+此时的输出结果是：
+
+```
+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` 可以唯一的获取到与它相关的调用了的方法（或者也可以理解成委托对象）。所以上面获取返回值的代码也可以改写成这样：
+```csharp
+private 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` 是一个委托类型，它用于方法的回调，即是说当异步方法执行完毕时自动进行调用的方法**。它的定义为：
+```csharp
+public delegate void AsyncCallback(IAsyncResult ar);
+```
+Object 类型用于传递任何你想要的数值，它可以通过IAsyncResult 的AsyncState 属性获得。下面我们将获取方法返回值、打印返回值的操作放到了OnAddComplete()回调方法中：
+```csharp
+using System.Threading;
+using System;
+using System.Runtime.Remoting.Messaging;
+public delegate int AddDelegate(int x, int y);
+class Program9
+{
+    static void Main(string[] args)
+    {
+        Console.WriteLine("Client application started!\n");
+        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("\nPress any key to exit...");
+        Console.ReadLine();
+    }
+ 
+    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}\n", Thread.CurrentThread.Name, rtn, data);
+    }
+}
+ 
+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;
+    }
+}
+```
+
+它产生的输出为：
+```
+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` 块中，这里就不再示范了。