C#里的委托和事件实现

原创 2005年05月29日 11:17:00
C#里的委托和事件实现Observer      选择自 possible_Y 的 Blog
关键字  C#里的委托和事件实现Observer
出处 

一、委托的简介

1、委托的声明:

<access modifier> delegate <returnType> HandlerName ([parameters])

例如:

public delegate void PrintHandler(string str);

 

      委托声明定义了一种类型,它用一组特定的参数以及返回类型来封装方法。对于静态方法,委托对象封装要调用的方法。对于实例方法,委托对象同时封装一个实例和该实例上的一个方法。如果您有一个委托对象和一组适当的参数,则可以用这些参数调用该委托。

 

2、委托的使用:

using System;

 

public class MyClass

{

                public static void Main()

                {

                                PrintStr myPrinter = new PrintStr();

                                PrintHandler myHandler = null;

                                myHandler += new PrintHandler(myPrinter.CallPrint); // 将委托链接到方法,来实例化委托

                                if(myHandler!=null)

                                                myHandler("Hello World!");    // 调用委托,相当于匿名调用委托所链接的方法

                                Console.Read();

                }

}

 

public delegate void PrintHandler(string str);    // 声明委托类型

 

public class PrintStr

{              

                public void CallPrint(string input)

                {

                                Console.WriteLine(input);

                }

}

 

 

C#中使用委托方法:

·          创建委托所使用的方法必须和委托声明相一致(参数列表、返回值都一致)

·          利用 +=-=来进行委托的链接、取消链接或直接使用Delegate.CombineDelegate.Remove方法来实现

·          可以使用MulticastDelegate的实例方法GetInvocationList()来获取委托链中所有的委托

·          不能撰写包含 out 参数的委托

 

二、事件的简介

C# 中的“事件”是当对象发生某些事情时,类向该类的客户提供通知的一种方法。

1、事件的声明:

声明的格式为:<access modifier> event <delegate type> EventName

 

        因为使用委托来声明事件,所以在类里声明事件时,首先必须先声明该事件的委托类型<delegate type>(如果尚未声明的话)。在上面我们已经提到过了委托类型的声明,但是在.net  framework下为事件使用的委托类型进行声明时有更严格的规定

1)、 事件的委托类型应采用两个参数;

2)、两个参数分别是:指示事件源的“对象源”参数和封装事件的其他任何相关信息的“e”参数;

3)、“e”参数的类型应为EventArgs 类或派生自 EventArgs 类。

如下的定义:

public delegate void PrintHandler(object sender,System.EventArgs e);

 

然后我们才能声明该委托类型的事件

例如:

public event PrintHandler Print;

当事件发生时,将调用其客户提供给它的委托。

 

2、调用事件:

        类声明了事件以后,可以就像处理所指示的委托类型的字段那样处理该事件。如果没有任何客户将委托与该事件绑定,则该字段将为空;否则该字段引用应在调用该事件时调用的委托。因此,调用事件时通常先检查是否为空,然后再调用事件。(调用事件,即触发事件,只能从声明该事件的类内进行)

 

if(Print != null)

{

                Print (this,e);

}

 

3、事件绑定:

        从类的外面来看,事件就象类的一个公共成员,通过 类名.事件名 的形式来访问,但是只能对它做绑定和解除绑定的操作,而不能有其他操作。

 

类名. Print += new PrintHandler(绑定的方法名)  // 将某个方法绑定到Print事件上

类名. Print  -= new PrintHandler(绑定的方法名)  // 将某个已绑定到Print事件上的方法从Print事件上解除

 

三、委托和事件的使用

委托和事件在用户界面程序里用的比较的多,比如象在winformwebform的用户UI上的button和它的click事件:

// Button1_Click()方法绑定到按钮控件Button1Click事件上

this.Button1.Click += new System.EventHandler(this. Button1_Click);

 

private void Button1_Click(object sender, System.EventArgs e)    // Button1_Click()方法

{

                …… 

}

 

然而除了用户界面程序外,在很多其他地方也用到了事件驱动模式,比如观察者模式(Observer)或发布/订阅(Publish/Subscribe)里:在一个类里发布(Publish)某个可以被触发的事件,而其他的类就可以来订阅(Subscribe)该事件。一旦这个发布者类触发了该事件,那么运行时环境会立刻告知所有订阅了该事件的订阅者类:这个事件发生了!从而各个订阅者类可以作出它们自己的反应(调用相应方法)。

 

我们来举一个生活中的实际例子来说明如何使用委托和事件,以及使用委托和事件所带来的好处:

 

比如说有一个公司(场景),你是老板,手下有主管员工,作为老板你会指派(委托)主管管理员工的工作,如果某个员工玩游戏,则让某个主管从该员工的薪水里扣去500元钱。

这就是现实中的委托。

而在写程序中,假设程序员就是老板,有两个类分别为主管员工,而主管小王员工小张就是两个类的对象实例。员工类一个方法:玩游戏,同时就有一个玩游戏的事件,他一玩游戏就会激发这个事件。而主管类就是负责处理该事件的,他负责把玩游戏的员工薪水扣除500

 

(一)、首先,我们来看看在非委托的情况下比较常见的一种设计方式(当然这不是唯一的方式,也不是最好的方式,但是很常见):

 

using System;

namespace CSharpConsole

{

                public class 场景

                {

                                [STAThread]

                                public static void Main(string[] args)

                                {

                                                Console.WriteLine("场景开始了.");

                                                // 生成主管类的对象实例 小王

                                                主管 小王 = new 主管();

                                                // 生成员工类的对象实例 小张,指定他的主管

                                                员工 小张 = new 员工(王);

                               

                                                Console.WriteLine("该员工本有的薪水:" + 小张.薪水.ToString());

           

                                                // 员工开始玩游戏

                                                小张.玩游戏();

 

                                                Console.WriteLine("现在该员工还剩下:" +小张.薪水.ToString());

                               

                                                Console.WriteLine("场景结束");

                                                Console.ReadLine();

                                }

                }

 

 

 

                // 负责扣钱的人----主管

                public class 主管

                {

                                public 主管()

                                {

                                                Console.WriteLine("生成主管");

                                }

 

                                public void 薪水(员工 employee)

                                {

                                                Console.WriteLine("主管:好小子,上班时间胆敢玩游戏");

                                                Console.WriteLine("主管:看看你小子有多少薪水");

                               

                                                Console.WriteLine("开始扣薪水...");

                                                System.Threading.Thread.Sleep(1000);

 

                                                employee.薪水 = employee.薪水 - 500;

 

                                                Console.WriteLine("扣薪水执行完毕.");          

                                }

                }

 

                // 如果玩游戏,则会引发事件

                public class 员工

                {

                                // 保存员工的薪水

                                private int m_Money;

                                // 保存该员工的主管

                                private 主管 m_Manager;

 

                                public 员工(主管 manager)

                                {

                                                Console.WriteLine("生成员工.");

                                                m_Manager = manager;  // 通过构造函数,初始化员工的主管。

                                                m_Money = 1000; // 通过构造函数,初始化员工的薪水。

                                }

 

                                public int 薪水 // 此属性可以操作员工的薪水 。

                                {

                                                get

                                                {

                                                                return m_Money;

                                                }

                                                set

                                                {

                                                                m_Money = value;

                                                }

                                }

 

                                public void 玩游戏()

                                {

                                                Console.WriteLine("员工开始玩游戏了..");

                                                Console.WriteLine("员工:CS真好玩,哈哈哈! 我玩...");

                                                System.Threading.Thread.Sleep(1000);

                                               

                                                m_Manager. 薪水(this);

                                }

                }

}


这种方法所带来的问题: 员工类和主管类的耦合性太高

1、   在客户程序里必须先创建了主管类之后才能生成员工类,如果在不需要主管类对象而只需员工类对象的地方,为了创建所需的员工类对象实例,你也不得不去先创建一个主管类的对象实例;

2、   如果场景剧本(即客户程序需求)发生了变化

1)、现在要让一个新的角色(一个新的类),如保安来代替主管,负责在员工玩游戏时扣员工薪水,那么我们不得不去修改员工类,或许还需要修改主管类;

2)、如果场景剧本增加新的需求,要求员工在玩游戏后,不但要扣薪水,还要在绩效上扣分,那么我们也不得不修改员工类


二)、利用委托的实现:

 

下面有个例子:在C# 控制台应用程序编辑运行成功:

 

using System;

namespace CSharpConsole

{

                // 定义委托

                public delegate void PlayGameHandler(object sender,System.EventArgs e);

 

                // 负责扣钱的人----主管

                public class 主管

                {

                                public 主管()

                                {

                                                Console.WriteLine("生成主管");

                                }

 

                                public void 薪水(object sender,EventArgs e)

                                {

                                                Console.WriteLine("主管:好小子,上班时间胆敢玩游戏");

                                                Console.WriteLine("主管:看看你小子有多少薪水");

               

                                                员工 employee = (员工)sender;

               

                                                Console.WriteLine("开始扣薪水...");

                                                System.Threading.Thread.Sleep(1000);

                                                employee.薪水 = employee.薪水 - 500;

                                                Console.WriteLine("扣薪水执行完毕.");          

                                }

                }

 

                // 如果玩游戏,则会引发事件

                public class 员工

                {

                                // 先定义一个事件,这个事件表示员工在玩游戏。

                                public event PlayGameHandler PlayGame;

                                // 保存员工薪水的变量

                                private int m_Money;

 

                                public 员工()

                                {

                                                Console.WriteLine("生成员工.");

                                                m_Money = 1000; // 构造函数,初始化员工的薪水。

                                }

 

                                public int 薪水 // 此属性可以操作员工的薪水 。

                                {

                                                get

                                                {

                                                                return m_Money;

                                                }

                                                set

                                                {

                                                                m_Money = value;

                                                }

                                }

 

                                public void 玩游戏()

                                {

                                                Console.WriteLine("员工开始玩游戏了..");

                                                Console.WriteLine("员工:CS真好玩,哈哈哈! 我玩...");

                                                System.Threading.Thread.Sleep(1000);

                                                System.EventArgs e = new EventArgs();

 

                                                OnPlayGame(e);

                                }

 

                                protected virtual void OnPlayGame(EventArgs e)

                                {

                                                if(PlayGame != null)

                                                {

                                                                PlayGame(this,e);

                                                }

                                }

                }

 

                public class 场景

                {

                                [STAThread]

                                public static void Main(string[] args)

                                {

                                                Console.WriteLine("场景开始了.");

                                                // 生成主管类的对象实例 小王

                                                主管 小王 = new 主管();

                                                // 生成员工类的对象实例 小张

                                                员工 小张 = new 员工();

 

                                                // 设下委托,指定监视

                                                小张.PlayGame += new PlayGameHandler(小王. 扣薪水);

                               

                                                Console.WriteLine("该员工本有的薪水:" + 小张.薪水.ToString());

            

                                                // 员工开始玩游戏

                                                小张.玩游戏();

 

                                                Console.WriteLine("现在该员工还剩下:" +小张.薪水.ToString());

                               

                                                Console.WriteLine("场景结束");

                                                Console.ReadLine();

                                }

                }

}

 

对于前面提出的问题:

1、   解耦了主管类员工类之间的必然联系,可以单独创建员工类对象实例,而不用管是否有主管类对象实例的存在;

2、   在客户程序需求变化时:

1)、我们只需修改客户程序,即上面例子里的class 场景,将委托改为如下:

 

保安 = new 保安();

小张.PlayGame += new PlayGameHandler(小. 扣薪水);

 

即可实现由保安来负责扣薪水的需求变化,而不用动员工类

2)、我们只需修改客户程序,即上面例子里的class 场景,添加一个如下的委托:

 

                小张.PlayGame += new PlayGameHandler(某某. 扣绩效分);

 

这个“某某”可以是主管,也可以是其他新的角色(新的类),只需要在“某某”对应的类里定义扣绩效分的动作即可,而不用动员工类

 

四、总结

      当然,不使用委托和事件我们仍然可以设计出解耦的类,然而却会增加很多的类、接口以及关联等等,增加了代码量和程序的逻辑复杂性,而在.net里利用委托和事件我们只需少的多的代码来实现。

 

  委托和事件的使用有如下几个要素:


1
、激发事件的对象-----就是员工小张
2
、处理对象事件的对象-----就是主管小王
3
、定义委托,就是你让主管小王监视员工小张

如果这三个要素都满足的话,则你就写出了一个完整事件的处理。
相关文章

C#里的委托和事件实现Observer(观察者)

一、委托的简介 1、委托的声明: delegate HandlerName ([parameters])  例如: public delegate void PrintHandler...
  • IIN22
  • IIN22
  • 2011年10月19日 11:38
  • 74

c#委托事件的实现

  • 2016年01月09日 14:10
  • 1.44MB
  • 下载

C#的委托事件在winform窗体中实现传值备忘

用一个例子来说明吧,这样比较好明白一些。就是打开主窗体,datagridview加载了一些数据,然后我们在打开的子窗体中,输入一些条件,让主窗体中的数据随着加载的条件来动态实现加载数据。这就需要涉及到...

C#的事件和委托实现(经典)

开始学习C#的时候,被委托和事件搞的很头痛,实例代码写了不少,就是老不知道委托到底除了定义事件还有什么用,事件到底是怎么触发的。前短时间看了CSDN上某大文章《事件与委托趣谈》,终于茅塞顿开,不敢独享...

C#使用委托创建事件实现两个窗体间通信

实例功能:一个简单的模拟登录窗口,程序运行后首先弹出一个登录对话框,对话框要求输入用户ID和密码,单击登录后主窗体上有两个标签显示登录输入的密码和用户ID;运行效果如下 开始运行 ...
  • yxtouch
  • yxtouch
  • 2014年09月10日 21:29
  • 836

C#事件与委托简单实现

假设我们有个高档的热水器(Heater),我们给它通上电,当水温超过95度的时候:1、扬声器(Alarm)会开始发出语音,告诉你水的温度;2、液晶屏(Display)也会改变水温的显示,来提示水已经快...

用 C++ 实现 C# 中的 委托/事件 (1-delegateEMU.cpp)

前两天看程序员杂志 看到关于 C# 中的委托/事件 觉得用起来好像是挺方便的 本人热衷于 C++ 想想用 C++ 来模拟似乎也可以 于是就有了下面的代码... (VC6 不支持偏特化 本人...
  • ilvu999
  • ilvu999
  • 2012年01月14日 09:32
  • 347

C#_delegate - 用委托实现事件,Display和Log类都使用Clock对象

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.T...

c# 用委托和事件实现不同窗体间的通讯

C# 中的“事件”是当对象满足一定条件,发生某些事情时,类向该类的客户提供通知的一种方法。使用事件,拥有该事件的对象不必知道需要通知谁,一旦满足了某个条件,将自动调用该事件,正确通知每个需要通知的对象...
  • jdwq33
  • jdwq33
  • 2014年08月04日 10:17
  • 343

游戏开发设计模式之状态模式 & 有限状态机 & c#委托事件(unity3d 示例实现)

说起状态模式游戏开发者们第一个想到的一定是AI的有限状态机FSMs,状态模式确实是实现有限状态机的一种方法。在有限状态机中,一般都是观察者模式与状态模式连用,状态模式把每个状态封装成类,来对每个输入消...
  • wolf96
  • wolf96
  • 2015年10月23日 10:12
  • 6183
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C#里的委托和事件实现
举报原因:
原因补充:

(最多只允许输入30个字)