C＃ 委托（Delegate） 事务（Event）应用详解(转)

委托 和 事务在 .Net Framework中的应用很是广泛，然而，较好地懂得委托和事务对很多接触C＃时候不长的人来说并不轻易。它们就像是一道槛儿，过了这个槛的人，感觉真是太轻易了，而没有畴昔的人每次见到委托和事务就感觉心里别（biè）得慌，混身不安闲。本文中，我将经由过程两个典范由浅入深地讲述什么是委托、为什么要应用委托、事务的由来、.Net Framework中的委托和事务、委托和事务对Observer设计模式的意义，对它们的中心代码也做了评论辩论。
 

将办法作为办法的参数
 

我们先不管这个题目如何的绕口，也不管委托毕竟是个什么器材，来看下面这两个最简单的办法，它们不过是在屏幕上输出一句问候的话语：
 

publicvoid GreetPeople（string name） {
    // 做某些额外的工作，比如初始化之类，此处略
    EnglishGreeting（name）;
}
publicvoid EnglishGreeting（string name） {
    Console.WriteLine（"Morning， " + name）;
}
 

暂且不管这两个办法有没有什么实际意义。GreetPeople用于向或人问好，当我们传递代表或人姓名的name参数，比如说“Jimmy”，进去的时辰，在这个办法中，将调用EnglishGreeting办法，再次传递name参数，EnglishGreeting则用于向屏幕输出 “Morning， Jimmy”。
 

如今假设这个法度须要进行全球化，哎呀，不好了，我是中国人，我不熟悉打听“Morning”是什么意思，怎么办呢？好吧，我们再加个中文版的问候办法：
 

publicvoid ChineseGreeting（string name）{
    Console.WriteLine（"早上好， " + name）;
}
 

这时辰，GreetPeople也须要改一改了，不然如何断定到底用哪个版本的Greeting问候办法合适呢？在进行这个之前，我们最好再定义一个列举作为断定的根据：
 

publicenumLanguage{
    English， Chinese
}

publicvoid GreetPeople（string name， Language lang）{
    //做某些额外的工作，比如初始化之类，此处略
    swith（lang）{
        case Language.English:
           EnglishGreeting（name）;
           break;
       case Language.Chinese:
           ChineseGreeting（name）;
           break;
    }
}
 

OK，尽管如许解决了题目，但我不说大师也很轻易想到，这个解决规划的可扩大性很差，若是日后我们须要再添加韩文版、日文版，就不得不反复批改列举和GreetPeople（）办法，以适应新的需求。
 

在推敲新的解决规划之前，我们先看看 GreetPeople的办法签名：
 

publicvoid GreetPeople（string name， Language lang）
 

我们仅看 string name，在这里，string 是参数类型，name 是参数变量，当我们赋给name字符串“jimmy”时，它就代表“jimmy”这个值；当我们赋给它“张子阳”时，它又代表着“张子阳”这个值。然后，我们可以在办法体内对这个name进行其他操纵。哎，这的确是空话么，刚学法度就知道了。
 

若是你再细心想想，假如GreetPeople（）办法可以接管一个参数变量，这个变量可以代表另一个办法，当我们给这个变量赋值 EnglishGreeting的时辰，它代表着 EnglsihGreeting（） 这个办法；当我们给它赋值ChineseGreeting 的时辰，它又代表着ChineseGreeting（）办法。我们将这个参数变量定名为 MakeGreeting，那么不是可以如同给name赋值时一样，在调用 GreetPeople（）办法的时辰，给这个MakeGreeting 参数也赋上值么（ChineseGreeting或者EnglsihGreeting等）？然后，我们在办法体内，也可以像应用此外参数一样应用MakeGreeting。然则，因为MakeGreeting代表着一个办法，它的应用体式格式应当和它被赋的办法（比如ChineseGreeting）是一样的，比如：
 

MakeGreeting（name）;
 

好了，有了思路了，我们如今就来改改GreetPeople（）办法，那么它应当是这个样子了：
 

publicvoid GreetPeople（string name， *** MakeGreeting）{
    MakeGreeting（name）;
}
 

重视到 *** ，这个地位凡是放置的应当是参数的类型，但到今朝为止，我们仅仅是想到应当有个可以代表办法的参数，并按这个思路去改写GreetPeople办法，如今就呈现了一个大题目：这个代表着办法的MakeGreeting参数应当是什么类型的？
 

NOTE：这里已不再须要列举了，因为在给MakeGreeting赋值的时辰动态地决意应用哪个办法，是ChineseGreeting还是 EnglishGreeting，而在这个两个办法内部，已经对应用“morning”还是“早上好”作了区分。
 

聪慧的你应当已经想到了，如今是委托该出场的时辰了，但讲述委托之前，我们再看看MakeGreeting参数所能代表的 ChineseGreeting（）和EnglishGreeting（）办法的签名：
 

publicvoid EnglishGreeting（string name）
publicvoid ChineseGreeting（string name）
 

如同name可以接管String类型的“true”和“1”，但不克不及接管bool类型的true和int类型的1一样。MakeGreeting的 参数类型定义 应当可以或许断定 MakeGreeting可以代表的办法种类，再进一步讲，就是MakeGreeting可以代表的办法 的 参数类型和返回类型。
 

于是，委托呈现了：它定义了MakeGreeting参数所能代表的办法的种类，也就是MakeGreeting参数的类型。
 

NOTE：若是上方这句话斗劲绕口，我把它翻译成如许：string 定义了name参数所能代表的值的种类，也就是name参数的类型。
 

本例中委托的定义：
 

publicdelegatevoid GreetingDelegate（string name）;
 

可以与上方EnglishGreeting（）办法的签名对比一下，除了参加了delegate关键字以外，其余的是不是完全一样？
 

如今，让我们再次批改GreetPeople（）办法，如下所示：
 

publicvoid GreetPeople（string name， GreetingDelegate MakeGreeting）{
    MakeGreeting（name）;
}
 

如你所见，委托GreetingDelegate呈现的地位与 string雷同，string是一个类型，那么GreetingDelegate应当也是一个类型，或者叫类（Class）。然则委托的声明体式格式和类却完全不合，这是怎么一回事？实际上，委托在编译的时辰确切会编译成类。因为Delegate是一个类，所以在任何可以声明类的处所都可以声明委托。更多的内容将鄙人面讲述，如今，请看看这个典范的完全代码：
 

using System;
using System.Collections.Generic;
using System.Text;

namespace Delegate {
     //定义委托，它定义了可以代表的办法的类型
     publicdelegatevoid GreetingDelegate（string name）;
        class Program {

           private static void EnglishGreeting（string name） {
               Console.WriteLine（"Morning， " + name）;
           }

           private static void ChineseGreeting（string name） {
               Console.WriteLine（"早上好， " + name）;
           }

           //重视此办法，它接管一个GreetingDelegate类型的办法作为参数
           private static void GreetPeople（string name， GreetingDelegate MakeGreeting） {
               MakeGreeting（name）;
            }

           static void Main（string[] args） {
               GreetPeople（"Jimmy Zhang"， EnglishGreeting）;
               GreetPeople（"张子阳"， ChineseGreeting）;
               Console.ReadKey（）;
           }
        }
    }

输出如下：
Morning， Jimmy Zhang
早上好， 张子阳
 

我们如今对委托做一个总结：
 

委托是一个类，它定义了办法的类型，使得可以将办法算作另一个办法的参数来进行传递，这种将办法动态地赋给参数的做法，可以避免在法度中多量应用If-Else（Switch）语句，同时使得法度具有更好的可扩大性。
 

将办法绑定到委托
 

看到这里，是不是有那么点如梦初醒的感触感染？于是，你是不是在想：在上方的例子中，我不必然要直接在GreetPeople（）办法中给 name参数赋值，我可以像如许应用变量：
 

staticvoid Main（string[] args） {
    string name1， name2;
    name1 = "Jimmy Zhang";
    name2 = "张子阳"; 

     GreetPeople（name1， EnglishGreeting）;
     GreetPeople（name2， ChineseGreeting）;
    Console.ReadKey（）;
}
 

而既然委托GreetingDelegate 和 类型 string 的地位一样，都是定义了一种参数类型，那么，我是不是也可以这么应用委托？
 

staticvoid Main（string[] args） {
    GreetingDelegate delegate1， delegate2;
    delegate1 = EnglishGreeting;
    delegate2 = ChineseGreeting;

    GreetPeople（"Jimmy Zhang"， delegate1）;
        GreetPeople（"张子阳"， delegate2）;
        Console.ReadKey（）;
}
 

如你所料，如许是没有题目的，法度一如预感的那样输出。这里，我想说的是委托不合于string的一个特点：可以将多个办法赋给同一个委托，或者叫将多个办法绑定到同一个委托，当调用这个委托的时辰，将依次调用其所绑定的办法。在这个例子中，语法如下：
 

staticvoid Main（string[] args） {
    GreetingDelegate delegate1;
    delegate1 = EnglishGreeting; // 先给委托类型的变量赋值
    delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个办法

     // 将先后调用 EnglishGreeting 与 ChineseGreeting 办法
    GreetPeople（"Jimmy Zhang"， delegate1）;  
    Console.ReadKey（）;
}

输出为：
Morning， Jimmy Zhang
早上好， Jimmy Zhang
 

实际上，我们可以也可以绕过GreetPeople办法，经由过程委托来直接调用EnglishGreeting和ChineseGreeting：
 

staticvoid Main（string[] args） {
    GreetingDelegate delegate1;
    delegate1 = EnglishGreeting; // 先给委托类型的变量赋值
    delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个办法

    // 将先后调用 EnglishGreeting 与 ChineseGreeting 办法
    delegate1 （"Jimmy Zhang"）;   
    Console.ReadKey（）;
}
 

 
 

NOTE：这在本例中是没有题目的，但回头看下上方GreetPeople（）的定义，在它之中可以做一些对于EnglshihGreeting和ChineseGreeting来说都须要进行的工作，为了简便我做了省略。
 

重视这里，第一次用的“=”，是赋值的语法；第二次，用的是“+=”，是绑定的语法。若是第一次就应用“+=”，将呈现“应用了未赋值的局部变量”的编译错误。
 

我们也可以应用下面的代码来如许简化这一过程：
 

GreetingDelegate delegate1 = newGreetingDelegate（EnglishGreeting）;
delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个办法
 

看到这里，应当重视到，这段代码第一条语句与实例化一个类是何其的类似，你不禁想到：上方第一次绑定委托时不成以应用“+=”的编译错误，或容许以用如许的办法来避免：
 

GreetingDelegate delegate1 = newGreetingDelegate（）;
delegate1 += EnglishGreeting;   // 此次用的是 “+=”，绑定语法。
delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个办法
 

但实际上，如许会呈现编译错误： “GreetingDelegate”办法没有采取“0”个参数的重载。尽管如许的成果让我们感觉有点沮丧，然则编译的提示：“没有0个参数的重载”再次让我们联想到了类的机关函数。我知道你必然按捺不住想探个毕竟，但再此之前，我们须要先把根蒂根基常识和应用介绍完。
 

既然给委托可以绑定一个办法，那么也应当有办法作废对办法的绑定，很轻易想到，这个语法是“-=”：
 

staticvoid Main（string[] args） {
    GreetingDelegate delegate1 = newGreetingDelegate（EnglishGreeting）;
    delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个办法

    // 将先后调用 EnglishGreeting 与 ChineseGreeting 办法
    GreetPeople（"Jimmy Zhang"， delegate1）;  
    Console.WriteLine（）;

    delegate1 -= EnglishGreeting; //作废对EnglishGreeting办法的绑定
    // 将仅调用 ChineseGreeting 
    GreetPeople（"张子阳"， delegate1）; 
    Console.ReadKey（）;
}
输出为：
Morning， Jimmy Zhang
早上好， Jimmy Zhang
早上好， 张子阳
 

让我们再次对委托作个总结：
 

应用委托可以将多个办法绑定到同一个委托变量，当调用此变量时（这里用“调用”这个词，是因为此变量代表一个办法），可以依次调用所有绑定的办法。
 

事务的由来
 

我们持续思虑上方的法度：上方的三个办法都定义在Programe类中，如许做是为了懂得的便利，实际应用中，凡是都是 GreetPeople 在一个类中，ChineseGreeting和 EnglishGreeting 在别的的类中。如今你已经对委托有了初步懂得，是时辰对上方的例子做个改进了。假设我们将GreetingPeople（）放在一个叫GreetingManager的类中，那么新法度应当是这个样子的：
 

namespace Delegate {
    //定义委托，它定义了可以代表的办法的类型
    publicdelegatevoid GreetingDelegate（string name）;
    
    //新建的GreetingManager类
    public class GreetingManager{
       public void GreetPeople（string name， GreetingDelegate MakeGreeting） {
           MakeGreeting（name）;
       }
    }

    class Program {
       private static void EnglishGreeting（string name） {
           Console.WriteLine（"Morning， " + name）;
       }

       private static void ChineseGreeting（string name） {
           Console.WriteLine（"早上好， " + name）;
       }

       static void Main（string[] args） {
           // ... ...
        }
    }
}
 

这个时辰，若是要实现前面演示的输出结果，Main办法我想应当是如许的：
 

staticvoid Main（string[] args） {
    GreetingManager gm = new  GreetingManager（）;
    gm.GreetPeople（"Jimmy Zhang"， EnglishGreeting）;
    gm.GreetPeople（"张子阳"， ChineseGreeting）;
}
 

我们运行这段代码，嗯，没有任何题目。法度一如预感地那样输出了：
 

Morning， Jimmy Zhang
 

早上好， 张子阳
 

如今，假设我们须要应用上一节学到的常识，将多个办法绑定到同一个委托变量，该如何做呢？让我们再次改写代码：
 

staticvoidMain（string[] args） {
    GreetingManager gm = new  GreetingManager（）;
    GreetingDelegate delegate1;
    delegate1 = EnglishGreeting;
    delegate1 += ChineseGreeting;

    gm.GreetPeople（"Jimmy Zhang"， delegate1）;
}

输出：
Morning， Jimmy Zhang
早上好， Jimmy Zhang
 

到了这里，我们不禁想到：面向对象设计，讲求的是对象的封装，既然可以声明委托类型的变量（在上例中是delegate1），我们何不将这个变量封装到 GreetManager类中？在这个类的客户端中应用不是更便利么？于是，我们改写GreetManager类，像如许：
 

publicclassGreetingManager{
    //在GreetingManager类的内部声明delegate1变量
    publicGreetingDelegate delegate1;  

    publicvoid GreetPeople（string name， GreetingDelegate MakeGreeting） {
       MakeGreeting（name）;
    }
}
 

如今，我们可以如许应用这个委托变量：
 

staticvoid Main（string[] args） {
    GreetingManager gm = new  GreetingManager（）;
    gm.delegate1 = EnglishGreeting;
    gm.delegate1 += ChineseGreeting;

    gm.GreetPeople（"Jimmy Zhang"， gm.delegate1）;
}

输出为：
Morning， Jimmy Zhang
早上好， Jimmy Zhang
 

尽管如许做没有任何题目，但我们发明这条语句很新鲜。在调用gm.GreetPeople办法的时辰，再次传递了gm的delegate1字段：
 

gm.GreetPeople（"Jimmy Zhang"， gm.delegate1）;
 

既然如此，我们何不批改 GreetingManager 类成如许：
 

publicclassGreetingManager{
    //在GreetingManager类的内部声明delegate1变量
    publicGreetingDelegate delegate1;  

    publicvoid GreetPeople（string name） {
        if（delegate1!=null）{     //若是有办法注册委托变量
          delegate1（name）;      //经由过程委托调用办法
       }
    }
}
 

在客户端，调用看上去更简洁一些：
 

staticvoid Main（string[] args） {
    GreetingManager gm = new  GreetingManager（）;
    gm.delegate1 = EnglishGreeting;
    gm.delegate1 += ChineseGreeting;

    gm.GreetPeople（"Jimmy Zhang"）;      //重视，此次不须要再传递 delegate1变量
}

输出为：
Morning， Jimmy Zhang
早上好， Jimmy Zhang
 

尽管如许达到了我们要的结果，然则还是存在着题目：
 

在这里，delegate1和我们日常平凡用的string类型的变量没有什么分别，而我们知道，并不是所有的字段都应当声明成public，合适的做法是应当public的时辰public，应当private的时辰private。
 

我们先看看若是把 delegate1 声明为 private会如何？成果就是：这的确就是在搞笑。因为声明委托的目标就是为了把它露出在类的客户端进行办法的注册，你把它声明为private了，客户端对它底子就不成见，那它还有什么用？
 

再看看把delegate1 声明为 public 会如何？成果就是：在客户端可以对它进行随便的赋值等操纵，严重破损对象的封装性。
 

最后，第一个办法注册用“=”，是赋值语法，因为要进行实例化，第二个办法注册则用的是“+=”。然则，不管是赋值还是注册，都是将办法绑定到委托上，除了调用时先后次序不合，再没有任何的分别，如许不是让人感觉很别扭么？
 

如今我们想想，若是delegate1不是一个委托类型，而是一个string类型，你会怎么做？答案是应用属性对字段进行封装。
 

于是，Event出场了，它封装了委托类型的变量，使得：在类的内部，不管你声明它是public还是protected，它老是private的。在类的外部，注册“+=”和刊出“-=”的接见限制符与你在声明事务时应用的接见符雷同。
 

我们改写GreetingManager类，它变成了这个样子：
 

publicclassGreetingManager{
    //这一次我们在这里声明一个事务
    publiceventGreetingDelegate MakeGreet;

    publicvoid GreetPeople（string name） {
        MakeGreet（name）;
    }
}
 

很轻易重视到：MakeGreet 事务的声明与之前委托变量delegate1的声明独一的差别是多了一个event关键字。看到这里，在连络上方的讲解，你应当熟悉打听到：事务其实没什么不好懂得的，声明一个事务不过类似于声明一个进行了封装的委托类型的变量罢了。
 

为了证实上方的推论，若是我们像下面如许改写Main办法：
 

staticvoid Main（string[] args） {
    GreetingManager gm = new  GreetingManager（）;
    gm.MakeGreet = EnglishGreeting;         // 编译错误1
    gm.MakeGreet += ChineseGreeting;

    gm.GreetPeople（"Jimmy Zhang"）;
}
 

会获得编译错误：事务“Delegate.GreetingManager.MakeGreet”只能呈如今 += 或 -= 的左边（从类型“Delegate.GreetingManager”中应用时除外）。
 

事务和委托的编译代码
 

这时辰，我们注释掉编译错误的行，然后从头进行编译，再借助Reflactor来对 event的声明语句做一商量，看看为什么会产生如许的错误：
 

publiceventGreetingDelegate MakeGreet;
 

 
 

可以看到，实际上尽管我们在GreetingManager里将 MakeGreet 声明为public，然则，实际上MakeGreet会被编译成 私有字段，难怪会产生上方的编译错误了，因为它底子就不容许在GreetingManager类的外面以赋值的体式格式接见，从而验证了我们上方所做的推论。
 

我们再进一步看下MakeGreet所产生的代码：
 

privateGreetingDelegate MakeGreet; //对事务的声明 实际是 声明一个私有的委托变量
 
[MethodImpl（MethodImplOptions.Synchronized）]
publicvoid add_MakeGreet（GreetingDelegate value）{
    this.MakeGreet = （GreetingDelegate） Delegate.Combine（this.MakeGreet， value）;
}

[MethodImpl（MethodImplOptions.Synchronized）]
publicvoid remove_MakeGreet（GreetingDelegate value）{
    this.MakeGreet = （GreetingDelegate） Delegate.Remove（this.MakeGreet， value）;
}
 

如今已经很明白了：MakeGreet事务确切是一个GreetingDelegate类型的委托，只不过不管是不是声明为public，它老是被声明为private。别的，它还有两个办法，分别是add_MakeGreet和remove_MakeGreet，这两个办法分别用于注册委托类型的办法和作废注册。实际上也就是： “+= ”对应 add_MakeGreet，“-=”对应remove_MakeGreet。而这两个办法的接见限制取决于声明事务时的接见限制符。
 

在add_MakeGreet（）办法内部，实际上调用了System.Delegate的Combine（）静态办法，这个办法用于将当前的变量添加到委托链表中。我们前面提到过两次，说委托实际上是一个类，在我们定义委托的时辰：
 

publicdelegatevoid GreetingDelegate（string name）;
 

当编译器碰到这段代码的时辰，会生成下面如许一个完全的类：
 

publicsealedclassGreetingDelegate:System.MulticastDelegate{
    public GreetingDelegate（object ＠object， IntPtr method）;
    publicvirtual IAsyncResult BeginInvoke（string name， AsyncCallback callback， object ＠object）;
    publicvirtualvoid EndInvoke（IAsyncResult result）;
    publicvirtualvoid Invoke（string name）;
}
 

 
 

关于这个类的更深切内容，可以参阅《CLR Via C＃》等相干册本，这里就不再评论辩论了。
 

委托、事务与Observer设计模式典范申明
 

上方的例子已不足以再进行下面的讲解了，我们来看一个新的典范，因为之前已经介绍了很多的内容，所以本节的进度会稍微快一些：
 

假设我们有个高等的热水器，我们给它通上电，当水温跨越95度的时辰：1、扬声器会开端发出语音，告诉你水的温度；2、液晶屏也会改变水温的显示，来提示水已经快烧开了。
 

如今我们须要写个法度来模仿这个烧水的过程，我们将定义一个类来代表热水器，我们管它叫：Heater，它有代表水温的字段，叫做temperature；当然，还有必不成少的给水加热办法BoilWater（），一个发出语音警报的办法MakeAlert（），一个显示水温的办法，ShowMsg（）。
 

namespace Delegate {
    classHeater {
    privateint temperature; // 水温
    // 烧水
    publicvoid BoilWater（） {
        for （int i = 0; i <= 100; i++） {
           temperature = i;

           if （temperature > 95） {
               MakeAlert（temperature）;
               ShowMsg（temperature）;
            }
        }
    }

    // 发出语音警报
    privatevoid MakeAlert（int param） {
       Console.WriteLine（"Alarm：嘀嘀嘀，水已经 {0} 度了：" ， param）;
    }
    
    // 显示水温
    privatevoid ShowMsg（int param） {
       Console.WriteLine（"Display：水快开了，当前温度：{0}度。" ， param）;
    }
}

classProgram {
    staticvoidMain（） {
       Heater ht = newHeater（）;
       ht.BoilWater（）;
    }
}
}
 

Observer设计模式简介
 

上方的例子显然能完成我们之前描述的工作，然则却并不敷好。如今假设热水器由三项目组构成：热水器、警报器、显示器，它们来自于不合厂商并进行了组装。那么，应当是热水器仅仅负责烧水，它不克不及发出警报也不克不及显示水温；在水烧开时由警报器发出警报、显示器显示提示和水温。
 

这时辰，上方的例子就应当变成这个样子：   
 

// 热水器
publicclassHeater { 
    privateint temperature;
        
    // 烧水
    privatevoid BoilWater（） {
       for （int i = 0; i <= 100; i++） {
           temperature = i;
        }
    }
}

// 警报器
publicclassAlarm{
    privatevoid MakeAlert（int param） {
       Console.WriteLine（"Alarm：嘀嘀嘀，水已经 {0} 度了：" ， param）;
    }
}

// 显示器
publicclassDisplay{
    privatevoid ShowMsg（int param） {
       Console.WriteLine（"Display：水已烧开，当前温度：{0}度。" ， param）;
    }
}
 

这里就呈现了一个题目：如安在水烧开的时辰通知报警器和显示器？在持续进行之前，我们先懂得一下Observer设计模式，Observer设计模式中首要包含如下两类对象：
 

Subject：把守对象，它往往包含着其他对象所感爱好的内容。在本典范中，热水器就是一个把守对象，它包含的其他对象所感爱好的内容，就是temprature字段，当这个字段的值快到100时，会络续把数据发给把守它的对象。Observer：把守者，它把守Subject，当Subject中的某件事产生的时辰，会告诉Observer，而Observer则会采取响应的步履。在本典范中，Observer有警报器和显示器，它们采取的步履分别是发出警报和显示水温。
 

在本例中，工作产生的次序应当是如许的：
 

警报器和显示器告诉热水器，它对它的温度斗劲感爱好（注册）。热水器知道后保存对警报器和显示器的引用。热水器进行烧水这一动作，当水温跨越95度时，经由过程对警报器和显示器的引用，主动调用警报器的MakeAlert（）办法、显示器的ShowMsg（）办法。
 

类似如许的例子是很多的，GOF对它进行了抽象，称为Observer设计模式：Observer设计模式是为了定义对象间的一种一对多的依附关系，以便于当一个对象的状况改变时，其他依附于它的对象会被主动告诉并更新。Observer模式是一种松耦合的设计模式。
 

实现典范的Observer设计模式
 

我们之前已经对委托和事务先允很多了，如今写代码应当很轻易了，如今在这里直接给出代码，并在注释中加以申明。
 

using System;
using System.Collections.Generic;
using System.Text;

namespace Delegate {
    // 热水器
    publicclassHeater {
       privateint temperature;
       publicdelegatevoid BoilHandler（int param）;   //声明委托
       publiceventBoilHandler BoilEvent;        //声明事务

       // 烧水
       publicvoid BoilWater（） {
           for （int i = 0; i <= 100; i++） {
              temperature = i;

              if （temperature > 95） {
                  if （BoilEvent != null） { //若是有对象注册
                      BoilEvent（temperature）;  //调用所有注册对象的办法
                  }
              }
           }
       }
    }

    // 警报器
    publicclassAlarm {
       publicvoid MakeAlert（int param） {
           Console.WriteLine（"Alarm：嘀嘀嘀，水已经 {0} 度了："， param）;
       }
    }

    // 显示器
    publicclassDisplay {
       publicstaticvoid ShowMsg（int param） { //静态办法
           Console.WriteLine（"Display：水快烧开了，当前温度：{0}度。"， param）;
       }
    }
    
    classProgram {
       staticvoidMain（） {
           Heater heater = newHeater（）;
           Alarm alarm = newAlarm（）;

           heater.BoilEvent += alarm.MakeAlert;    //注册办法
           heater.BoilEvent += （new Alarm（））.MakeAlert;   //给匿名对象注册办法
           heater.BoilEvent += Display.ShowMsg;       //注册静态办法

           heater.BoilWater（）;   //烧水，会主动调用注册过对象的办法
       }
    }
}
输出为：
Alarm：嘀嘀嘀，水已经 96 度了：
Alarm：嘀嘀嘀，水已经 96 度了：
Display：水快烧开了，当前温度：96度。
// 省略...
 

.Net Framework中的委托与事务
 

尽管上方的典范很好地完成了我们想要完成的工作，然则我们不仅困惑：为什么.Net Framework 中的事务模型和上方的不合？为什么有很多的EventArgs参数？
 

在答复上方的题目之前，我们先搞懂 .Net Framework的编码规范：
 

委托类型的名称都应当以EventHandler停止。委托的原型定义：有一个void返回值，并接管两个输入参数：一个Object 类型，一个 EventArgs类型（或持续自EventArgs）。事务的定名为 委托去掉 EventHandler之后残剩的项目组。持续自EventArgs的类型应当以EventArgs结尾。
 

再做一下申明：
 

委托声明原型中的Object类型的参数代表了Subject，也就是把守对象，在本例中是 Heater（热水器）。回调函数（比如Alarm的MakeAlert）可以经由过程它接见触发事务的对象（Heater）。EventArgs 对象包含了Observer所感爱好的数据，在本例中是temperature。
 

上方这些其实不仅仅是为了编码规范罢了，如许也使得法度有更大的灵活性。比如说，若是我们不但想获得热水器的温度，还想在Observer端（警报器或者显示器）办法中获得它的临盆日期、型号、价格，那么委托和办法的声明都邑变得很麻烦，而若是我们将热水器的引用传给警报器的办法，就可以在办法中直接接见热水器了。
 

如今我们改写之前的典范，让它合适 .Net Framework 的规范：
 

using System;
using System.Collections.Generic;
using System.Text;

namespace Delegate {
    // 热水器
    publicclassHeater {
       privateint temperature;
       publicstring type = "RealFire 001";       // 添加型号作为演示
       publicstring area = "China Xian";         // 添加产地作为演示
       //声明委托
       publicdelegatevoid BoiledEventHandler（Object sender， BoiledEventArgs e）;
       publiceventBoiledEventHandler Boiled; //声明事务

       // 定义BoiledEventArgs类，传递给Observer所感爱好的信息
       publicclassBoiledEventArgs : EventArgs {
           publicreadonlyint temperature;
           public BoiledEventArgs（int temperature） {
              this.temperature = temperature;
           }
       }

       // 可以供持续自 Heater 的类重写，以便持续类拒绝其他对象对它的把守
       protectedvirtualvoid OnBoiled（BoiledEventArgs e） {
           if （Boiled != null） { // 若是有对象注册
              Boiled（this， e）;  // 调用所有注册对象的办法
           }
       }
       
       // 烧水。
       publicvoid BoilWater（） {
           for （int i = 0; i <= 100; i++） {
              temperature = i;
              if （temperature > 95） {
                  //建树BoiledEventArgs 对象。
                  BoiledEventArgs e = new BoiledEventArgs（temperature）;
                  OnBoiled（e）;  // 调用 OnBolied办法
              }
           }
       }
    }

    // 警报器
    publicclassAlarm {
       publicvoid MakeAlert（Object sender， Heater.BoiledEventArgs e） {
           Heater heater = （Heater）sender;     //这里是不是很熟悉呢？
           //接见 sender 中的公共字段
           Console.WriteLine（"Alarm：{0} - {1}: "， heater.area， heater.type）;
           Console.WriteLine（"Alarm: 嘀嘀嘀，水已经 {0} 度了："， e.temperature）;
           Console.WriteLine（）;
       }
    }

    // 显示器
    publicclassDisplay {
       publicstaticvoid ShowMsg（Object sender， Heater.BoiledEventArgs e） {   //静态办法
           Heater heater = （Heater）sender;
           Console.WriteLine（"Display：{0} - {1}: "， heater.area， heater.type）;
           Console.WriteLine（"Display：水快烧开了，当前温度：{0}度。"， e.temperature）;
           Console.WriteLine（）;
       }
    }

    classProgram {
       staticvoid Main（） {
           Heater heater = newHeater（）;
           Alarm alarm = newAlarm（）;

           heater.Boiled += alarm.MakeAlert;   //注册办法
           heater.Boiled += （new Alarm（））.MakeAlert;      //给匿名对象注册办法
           heater.Boiled += new Heater.BoiledEventHandler（alarm.MakeAlert）;    //也可以这么注册
           heater.Boiled += Display.ShowMsg;       //注册静态办法

           heater.BoilWater（）;   //烧水，会主动调用注册过对象的办法
       }
    }
}

输出为：
Alarm：China Xian - RealFire 001:
Alarm: 嘀嘀嘀，水已经 96 度了：
Alarm：China Xian - RealFire 001:
Alarm: 嘀嘀嘀，水已经 96 度了：
Alarm：China Xian - RealFire 001:
Alarm: 嘀嘀嘀，水已经 96 度了：
Display：China Xian - RealFire 001:
Display：水快烧开了，当前温度：96度。
// 省略 ...
 

总结
 

在本文中我起首经由过程一个GreetingPeople的小法度向大师介绍了委托的概念、委托用来做什么，随后又引出了事务，接着对委托与事务所产生的中心代码做了粗略的讲述。
 

在第二个稍微错杂点的热水器的典范中，我向大师扼要介绍了 Observer设计模式，并经由过程实现这个典范完成了该模式，随后讲述了.Net Framework中委托、事务的实现体式格式。
 

----------------------------------------------补充申明--------------------------------------------------
 

委托 （Delegate）
 

委托是一种定义办法签名的类型，可以与具有兼容签名的任何办法接洽关系。您可以经由过程委托调用办法。委托用于将办法作为参数传递给其他办法。事务处理惩罚法度就是经由过程委托调用的办法。与委托的签名匹配的任何可接见类或布局中的任何办法都可以分派给该委托。办法可所以静态办法，也可所以实例办法。如许就可以经由过程编程体式格式来更改办法调用，还可以向现有类中插入新代码。只要知道委托的签名，就可以分派您本身的办法。
 

多播委托（Multi-Broadcast Delegate）
 

多播委托是指引用多个办法委托。当调用委托时，它连气儿调用每个办法。为了把委托的单个实例归并为一个多播委托，委托必须是同类型的，返回类型必须是void，不克不及带输出参数（但可以带引用参数），若是委托是有返回值的函数，则只能调用最后一个委托函数。 除此之外，它们的声明和实例化都和其他委托没有什么不合。多播委托用于C＃的事务模型中。您可以把多播委托看作两个或多个标准委托串在一路。委托可以应用算术运算符+和+=串在一路。委托也能应用-和-=运算符从多播委托中删除。当调用多播委托里，委托所默示的每个办法依次调用。若是有任何参数，它们将用于所有的办法。
 





源代码:


 













using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace CSFramework.Tech.Delegate
{
   
   //测试用例 
   public class TestClasses
   {
      //测试委托 
      public void TestDelegate（）
      {
         A a = new A（）;
         B b = new B（）;
         
         b.SetDelegateMethod（a.A_Method）; //给A对象设置一个委托，该委托是委托A对象内的A_Method办法 
         b.TestDelegate（）; //测试这个委托。重视提示信息 
      }
      
      //测试事务 
      public void TestEvent（）
      {
         A a = new A（）;
         B b = new B（）;

         //给b对象的MyEven事务绑定一个委托办法，该委托是委托A对象内的A_Method办法 
         b.MyEven += new MethodInvoke（a.A_Method）; 
         b.TestEvent（）; //测试这个事务。重视提示信息 
      }
      
      //测试多播 
      public void TestMultiBroadcast（）
      {
         A a = new A（）;
         B b = new B（）;
         
         b.MyEven += new MethodInvoke（a.A_Method）; //给b对象的MyEven事务绑定一个委托办法A_Method 
         b.MyEven += new MethodInvoke（a.AA_Method）; //给b对象的MyEven事务绑定一个委托办法AA_Method 
         

         b.TestEvent（）; //测试这个事务。重视提示信息 
      }
      
      private WriteLogMethod _logMethod = null;
      private Form _owner = null;
      
      //测试线程内调用委托 
      public void TestDelegateInThread（Form owner，WriteLogMethod method）
      {
         _logMethod = method;
         _owner = owner;
         
         Thread t = new Thread（new ThreadStart（Run））;
         t.Start（）;//开端运行线程 
      }
      
      //多线程内的办法 
      private void Run（）
      {
         // 
         //直接调用_logMethod（）尝尝？ 会抛出异常: 
         //Cross-thread operation not valid: Control """"""""listBox1"""""""" accessed a thread other than the thread it was created on. 
         // 
          /* 
          _logMethod（"多线程内的输出数据1"）; 
          _logMethod（"多线程内的输出数据2"）; 
          _logMethod（"多线程内的输出数据3"）; 
          */ 
         
         
         // Control.Invoke（）办法申明: 
         // utes the specified delegate， on the thread that owns the control""""""""s underlying 
         // window handle， with the specified list of arguments. 
         // 
         _owner.Invoke（_logMethod， "多线程内的输出数据1"）;
         _owner.Invoke（_logMethod， "多线程内的输出数据2"）;
         _owner.Invoke（_logMethod， "多线程内的输出数据3"）;
      }
      
   }
   
   /// <summary> 
   /// 定义一个由多线程调用的委托类型.用于显示多线程内输出的数据. 
   /// </summary> 
   public delegate void WriteLogMethod（string log）;
   
   /// <summary> 
   /// 定义一个自定义委托类型 
   /// </summary> 
   public delegate void MethodInvoke（）;
   
   
   //测试类A 
   public class A
   {
      public void A_Method（）
      {
         MessageBox.Show（"A对象内的A_Method办法!"）;
      }
      
      public void AA_Method（）
      {
         MessageBox.Show（"A对象内的AA_Method办法!"）;
      }
   }
   
   //测试类B 
   public class B
   {
      public void B_Method（）
      {
         MessageBox.Show（"B对象内的办法!"）;
      }
      
      //委托办法变量 
      private MethodInvoke _delegateMethod;
      
      public void SetDelegateMethod（MethodInvoke method）
      {
         _delegateMethod = method;
      }
      
      //测试由外部传进来的委托事务. 
      public void TestDelegate（）
      {
         if （_delegateMethod != null） _delegateMethod（）;
      }
      
      //事务变量 
      private event MethodInvoke _MyEvent = null;
      
      /// <summary> 
      /// 给对象定义一个事务。 
      /// 重视事务定义的标准语法，add，remove 
      /// </summary> 
      public event MethodInvoke MyEven
      {
         add { _MyEvent += new MethodInvoke（value）; }
         remove { _MyEvent -= new MethodInvoke（value）; }
      }
      
      //测试对象的事务。 
      public void TestEvent（）
      {
         if （_MyEvent != null） _MyEvent（）;
      }
   }
}

 

若是委托是有返回值的函数，则只能调用最后一个委托函数:


 


//测试有返回值的多播。 
public void TestReturnValueEvent（）
{
   A a = new A（）;
   B b = new B（）;
   
   //产生有返回值的多播事务 
   b.ReturnValueEvent += new GetValueInvoke（a.GetValueA）; //注:GetValueA（）函数返回int 100 
   b.ReturnValueEvent += new GetValueInvoke（a.GetValueB）; //注:GetValueB（）函数返回int 200 
   
   b.TestEvent1（）; //显示成果200; =a.GetValueB（）;
      
   A a1 = new A（）;
   B b1 = new B（）;
   
   //产生有返回值的多播事务- 次序相反 
   b1.ReturnValueEvent += new GetValueInvoke（a1.GetValueB）; //注:GetValueB（）函数返回int 200 
   b1.ReturnValueEvent += new GetValueInvoke（a1.GetValueA）; //注:GetValueA（）函数返回int 100 
   
   b1.TestEvent1（）; //显示成果100; =a1.GetValueA（）;
}
 

证实：有返回值的函数用于多播是失败的!

连络测试用例思虑:

为什么b.SetDelegateMethod（）与b.MyEven += new MethodInvoke（a.A_Method）显示成果一致，但有什么差别呢？
申明:b.SetDelegateMethod（）是调用SetDelegateMethod办法给b对象内的_delegateMethod变量赋值。
而b.MyEven += new MethodInvoke（a.A_Method）是给b.MyEven事务绑定一个MethodInvoke类型办法。应用"+="操纵符默示给b.MyEven事务同时绑定多个办法，这就是C＃内的多播应用。
是以b.SetDelegateMethod（）是调用办法而b.MyEven += new MethodInvoke（a.A_Method）是给事务绑定办法。