C#事件的由来

开发 后端
本文讲述了C#事件的由来,希望对大家有所帮助。

在介绍C#事件的由来之前,我们继续思考上面的程序:上面的三个方法都定义在Programe类中,这样做是为了理解的方便,实际应用中,通常都是 GreetPeople 在一个类中,ChineseGreeting和 EnglishGreeting 在另外的类中。现在你已经对委托有了初步了解,是时候对上面的例子做个改进了。假设我们将GreetingPeople()放在一个叫GreetingManager的类中,那么新程序应该是这个样子的:

  1. namespace Delegate {  
  2.     //定义委托,它定义了可以代表的方法的类型  
  3.     public delegate void GreetingDelegate(string name);  
  4.       
  5.     //新建的GreetingManager类  
  6.     public class GreetingManager{  
  7.        public void GreetPeople(string name, GreetingDelegate MakeGreeting) {  
  8.            MakeGreeting(name);  
  9.        }  
  10.     }  
  11.  
  12.     class Program {  
  13.        private static void EnglishGreeting(string name) {  
  14.            Console.WriteLine("Morning, " + name);  
  15.        }  
  16.  
  17.        private static void ChineseGreeting(string name) {  
  18.            Console.WriteLine("早上好, " + name);  
  19.        }  
  20.  
  21.        static void Main(string[] args) {  
  22.            // ... ...  
  23.         }  
  24.     }  

这个时候,如果要实现前面演示的输出效果,Main方法我想应该是这样的:

  1. static void Main(string[] args) {  
  2.     GreetingManager gm = new  GreetingManager();  
  3.     gm.GreetPeople("Jimmy Zhang", EnglishGreeting);  
  4.     gm.GreetPeople("张子阳", ChineseGreeting);  

我们运行这段代码,嗯,没有任何问题。程序一如预料地那样输出了:

  1. Morning, Jimmy Zhang  
  2.  
  3. 早上好, 张子阳 

现在,假设我们需要使用上一节学到的知识,将多个方法绑定到同一个委托变量,该如何做呢?让我们再次改写代码:

  1. static void Main(string[] args) {  
  2.     GreetingManager gm = new  GreetingManager();  
  3.     GreetingDelegate delegate1;  
  4.     delegate1 = EnglishGreeting;  
  5.     delegate1 += ChineseGreeting;  
  6.  
  7.     gm.GreetPeople("Jimmy Zhang", delegate1);  

输出:

  1. Morning, Jimmy Zhang  
  2. 早上好, Jimmy Zhang 

到了这里,我们不禁想到:面向对象设计,讲究的是对象的封装,既然可以声明委托类型的变量(在上例中是delegate1),我们何不将这个变量封装到 GreetManager类中?在这个类的客户端中使用不是更方便么?于是,我们改写GreetManager类,像这样:

  1. public class GreetingManager{  
  2.     //在GreetingManager类的内部声明delegate1变量  
  3.     public GreetingDelegate delegate1;    
  4.  
  5.     public void GreetPeople(string name, GreetingDelegate MakeGreeting) {  
  6.        MakeGreeting(name);  
  7.     }  

现在,我们可以这样使用这个委托变量:

  1. static void Main(string[] args) {  
  2.     GreetingManager gm = new  GreetingManager();  
  3.     gm.delegate1 = EnglishGreeting;  
  4.     gm.delegate1 += ChineseGreeting;  
  5.  
  6.     gm.GreetPeople("Jimmy Zhang", gm.delegate1);  

输出为:

  1. Morning, Jimmy Zhang  
  2. 早上好, Jimmy Zhang 

尽管这样做没有任何问题,但我们发现这条语句很奇怪。在调用gm.GreetPeople方法的时候,再次传递了gm的delegate1字段:

  1. gm.GreetPeople("Jimmy Zhang", gm.delegate1); 

既然如此,我们何不修改 GreetingManager 类成这样:

  1. public class GreetingManager{  
  2.     //在GreetingManager类的内部声明delegate1变量  
  3.     public GreetingDelegate delegate1;    
  4.  
  5.     public void GreetPeople(string name) {  
  6.         if(delegate1!=null){     //如果有方法注册委托变量  
  7.           delegate1(name);      //通过委托调用方法  
  8.        }  
  9.     }  

在客户端,调用看上去更简洁一些:

  1. static void Main(string[] args) {  
  2.     GreetingManager gm = new  GreetingManager();  
  3.     gm.delegate1 = EnglishGreeting;  
  4.     gm.delegate1 += ChineseGreeting;  
  5.  
  6.     gm.GreetPeople("Jimmy Zhang");      //注意,这次不需要再传递 delegate1变量  

输出为:

  1. Morning, Jimmy Zhang  
  2. 早上好, Jimmy Zhang 

尽管这样达到了我们要的效果,但是还是存在着问题:

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

我们先看看如果把 delegate1 声明为 private会怎样?结果就是:这简直就是在搞笑。因为声明委托的目的就是为了把它暴露在类的客户端进行方法的注册,你把它声明为private了,客户端对它根本就不可见,那它还有什么用?

再看看把delegate1 声明为 public 会怎样?结果就是:在客户端可以对它进行随意的赋值等操作,严重破坏对象的封装性。

***,***个方法注册用“=”,是赋值语法,因为要进行实例化,第二个方法注册则用的是“+=”。但是,不管是赋值还是注册,都是将方法绑定到委托上,除了调用时先后顺序不同,再没有任何的分别,这样不是让人觉得很别扭么?

现在我们想想,如果delegate1不是一个委托类型,而是一个string类型,你会怎么做?答案是使用属性对字段进行封装。

于是,Event出场了,它封装了委托类型的变量,使得:在类的内部,不管你声明它是public还是protected,它总是private的。在类的外部,注册“+=”和注销“-=”的访问限定符与你在声明事件时使用的访问符相同。

我们改写GreetingManager类,它变成了这个样子:

  1. public class GreetingManager{  
  2.     //这一次我们在这里声明一个事件  
  3.     public event GreetingDelegate MakeGreet;  
  4.  
  5.     public void GreetPeople(string name) {  
  6.         MakeGreet(name);  
  7.     }  

很容易注意到:MakeGreet 事件的声明与之前委托变量delegate1的声明唯一的区别是多了一个event关键字。看到这里,在结合上面的讲解,你应该明白到:C#事件事件其实没什么不好理解的,声明一个事件不过类似于声明一个进行了封装的委托类型的变量而已。

为了证明上面的推论,如果我们像下面这样改写Main方法:

  1. static void Main(string[] args) {  
  2.     GreetingManager gm = new  GreetingManager();  
  3.     gm.MakeGreet = EnglishGreeting;         // 编译错误1  
  4.     gm.MakeGreet += ChineseGreeting;  
  5.  
  6.     gm.GreetPeople("Jimmy Zhang");  

会得到编译错误:事件“Delegate.GreetingManager.MakeGreet”只能出现在 += 或 -= 的左边(从类型“Delegate.GreetingManager”中使用时除外)。

以上就是C#事件的由来。

【编辑推荐】

  1. C#调用SQL存储过程示例演示
  2. C#与SQL连接:GridView控件操作
  3. ASP调用C# DLL发送邮件方法共享
  4. VC6.0和VS2005:C++和C#编写调用COM组件
  5. C#中调用dll库(VC编写)
责任编辑:book05 来源: cnblogs
相关推荐

2009-08-07 17:57:26

C#定义事件应用

2009-08-28 09:43:05

C#事件

2009-08-31 18:01:41

C#接口事件

2009-08-12 15:20:21

C#事件处理

2009-08-28 13:12:02

C# Page_Err

2009-08-13 10:42:31

C#窗体拖动事件

2009-08-27 18:02:22

C#事件处理

2009-08-03 13:23:04

C#编程组件-事件-委托

2009-09-07 15:31:49

C#支持事件

2009-08-12 18:28:09

C#事件处理程序

2009-09-07 04:19:56

C#窗体事件

2009-09-10 18:18:42

C# Button

2011-04-25 09:22:44

C#事件

2009-08-28 14:28:25

C# Applicat

2009-08-18 10:54:17

C#事件和委托

2009-08-04 09:56:46

C#事件处理自定义事件

2009-08-04 13:53:58

C#委托类C#事件

2009-08-04 12:56:51

C#自定义事件

2009-09-07 05:31:39

C#窗体关闭事件

2009-08-27 16:53:01

C#委托C#事件
点赞
收藏

51CTO技术栈公众号