委托和事件

最近使用的比较多的delegate和event ，在使用之后发现自己只知其皮毛，故重新学习之。在论坛得一较好资料，学习，体会

一、委托的简介

1 、委托的声明：

<access modifier> delegate <returnType> Handler Name ([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.Combine 和 Delegate.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 事件上解除

 

三、委托和事件的使用

委托和事件在用户界面程序里用的比较的多，比如象在 winform 或 webform 的用户 UI 上的 button 和它的 click 事件：

// 将 Button1_Click() 方法绑定到按钮控件 Button1 的 Click 事件上

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 、定义委托，就是你让 主管小王 监视 员工小张 。

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

/

体会：

1 ．

在项目开发中遇到从不是创建UI控件的线程访问该控件，更新其内容。查找到2种方法。一种是仅仅使用delagate.如下例子：

        // 更新ListBox信息

        public delegate void UpdateListBoxCallback();

 

        // 更新用户列表

        private void UpdateClientListControl()

        {

            if (InvokeRequired)

            {

listBoxClientList.BeginInvoke(new UpdateListBoxCallback(UpdateClientList), null);

            }

            else

            {

                // 创建该控件的主线程直接更新信息列表

                UpdateClientList();

            }

        }

// 更新代码在这里

        public void UpdateClientList()

        {

            listBoxClientList.Items.Clear();

            for (int index = 0; index < WorkerSocketList.Count; index++)

            {

                string clientKey = Convert.ToString(index + 1);

                Socket workerSocket = (Socket)WorkerSocketList[index];

                if (workerSocket != null)

                {

                    // 将连接着服务器的客户添加到客户列表中

                    if (workerSocket.Connected)

                    {

                        listBoxClientList.Items.Add(clientKey);

                    }

                }

            }

        }

 

2 ．后来又使用了event的方法。发现使用event的方法在刷新UI的效率和资源占用上都优于上面的方法1

还是拿例子说话：

// 代码来自 自己的 远程唤醒(WOL)程序

// 事件一

// 声名

        public delegate void ShowMacInList(ListBox listBox, object obj);

        public event ShowMacInList ShowAllRresultInList;

// 链接

this .ShowAllRresultInList += new ShowMacInList(RWOL_ShowAllRresultInList);

//

        void RWOL_ShowAllRresultInList(ListBox listBox, object obj)

        {

            try

            {

                this.BeginInvoke(new ShowMacInList(ShowResult),

                                new object[] { listBox, obj });

            }

            catch

            {

          

// 在线程中使用

   ShowAllRresultInList(listBoxScanResult, ScanResultMessage[count]);

 

// 事件二

        public delegate void UpdateButton(Button button, bool enable,string text);

        public event UpdateButton UpdateFormButton;

 

this .UpdateFormButton += new UpdateButton(RWOL_UpdateFormButton);

 

        void RWOL_UpdateFormButton(Button button, bool enable, string text)

        {

            try

            {

                this.BeginInvoke(new UpdateButton(UpdateButtons),

                                new object[] { button, enable,text });

            }

            catch

            {

            }

        }

// 线程中使用

UpdateFormButton(buttonScan, false, "");

 

这里事件二和

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

（ 1 ）、 事件的委托类型应采用两个参数；

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

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

规定的2个参数并不相符。但是细细想想，原理是一样地的，只是这里把发送者具体化了，把参数也具体化了