`

C# 中的委托和事件

CC++C#Linq设计模式 
阅读更多

将方法作为方法的参数

如你所见，委托GreetingDelegate出现的位置与 string相同，string是一个类型，那么GreetingDelegate应该也是一个类型，或者叫类(Class)。但是委托的声明方式和类却完全不同，这是怎么一回事？实际上，委托在编译的时候确实会编译成类。因为Delegate是一个类，所以在任何可以声明类的地方都可以声明委托。更多的内容将在下面讲述，现在，请看看这个范例的完整代码：

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

namespace EventAndDelegateDemo
{
    public delegate void 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("Frank Huan", EnglishGreeting);
            GreetPeople("冯焕", ChineseGreeting);
            Console.ReadKey();
        }

    }
}

 

我们现在对委托做一个总结：

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

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

namespace EventAndDelegateDemo
{
    public delegate void 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)
        {
            //注意委托一定要放入一个要委托的方法
            GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
            delegate1 += ChineseGreeting;   // 给此委托变量再绑定一个方法

            // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
            GreetPeople("Frank Huan", delegate1);
            Console.WriteLine();

            delegate1 -= EnglishGreeting; //取消对EnglishGreeting方法的绑定
            // 将仅调用 ChineseGreeting 
            GreetPeople("冯焕", delegate1);
            Console.ReadKey();

        }

    }
}

 

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

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

 

 

事件的由来

GreetingManager.cs

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

namespace EventAndDelegateDemo.fh
{
    public delegate void GreetingDelegate(string name);
    public class GreetingManager
    {
        //在GreetingManager类的内部声明delegate1变量
        public GreetingDelegate delegate1;

        public void GreetPeople(string name)
        {
            if (delegate1 != null)
            {     //如果有方法注册委托变量
                delegate1(name);      //通过委托调用方法
            }
        }
    }


}

 

main.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EventAndDelegateDemo.fh;
namespace EventAndDelegateDemo
{
    
    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)
        {
            
            GreetingManager gm = new GreetingManager();
            gm.delegate1 = EnglishGreeting;
            gm.delegate1 += ChineseGreeting;

            gm.GreetPeople("Jimmy Zhang");      //注意，这次不需要再传递 delegate1变量
            Console.ReadKey();

        }

    }
}

 

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

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

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

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

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

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

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

 

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

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

namespace EventAndDelegateDemo.fh
{
    public delegate void GreetingDelegate(string name);
    public class GreetingManager
    {
        //在GreetingManager类的内部声明delegate1变量
        public event GreetingDelegate MakeGreet;

        public void GreetPeople(string name)
        {
            MakeGreet(name);
        }
    }


}

 

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EventAndDelegateDemo.fh;
namespace EventAndDelegateDemo
{
    
    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)
        {
            
            GreetingManager gm = new GreetingManager();
            gm.MakeGreet += EnglishGreeting;
            gm.MakeGreet += ChineseGreeting;

            gm.GreetPeople("Frank Huan");      //注意，这次不需要再传递 delegate1变量
            Console.ReadKey();

            
        }

    }
}

 

 

委托、事件与Observer设计模式

范例说明

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

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

现在我们需要写个程序来模拟这个烧水的过程，我们将定义一个类来代表热水器，我们管它叫：Heater，它有代表水温的字段，叫做temperature；当然，还有必不可少的给水加热方法BoilWater()，一个发出语音警报的方法MakeAlert()，一个显示水温的方法，ShowMsg()。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EventAndDelegateDemo.fh;
namespace EventAndDelegateDemo
{

    class Heater
    {
        private int temperature; // 水温
        // 烧水
        public void BoilWater()
        {
            for (int i = 0; i <= 100; i++)
            {
                temperature = i;

                if (temperature > 95)
                {
                    MakeAlert(temperature);
                    ShowMsg(temperature);
                }
            }
        }

        // 发出语音警报
        private void MakeAlert(int param)
        {
            Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：", param);
        }

        // 显示水温
        private void ShowMsg(int param)
        {
            Console.WriteLine("Display：水快开了，当前温度：{0}度。", param);
        }
    }

    class Program
    {
        static void Main()
        {
            Heater ht = new Heater();
            ht.BoilWater();
        }
    }

}

 

 

Observer设计模式简介

上面的例子显然能完成我们之前描述的工作，但是却并不够好。现在假设热水器由三部分组成：热水器、警报器、显示器，它们来自于不同厂商并进行了组装。那么，应该是热水器仅仅负责烧水，它不能发出警报也不能显示水温；在水烧开时由警报器发出警报、显示器显示提示和水温。

这时候，上面的例子就应该变成这个样子：   

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EventAndDelegateDemo.fh;
namespace EventAndDelegateDemo
{

    // 热水器
    public class Heater {
       private int temperature;
       public delegate void BoilHandler(int param);   //声明委托
       public event BoilHandler BoilEvent;        //声明事件

       // 烧水
       public void BoilWater() {
           for (int i = 0; i <= 100; i++) {
              temperature = i;

              if (temperature > 95) {
                  if (BoilEvent != null) { //如果有对象注册
                      BoilEvent(temperature);  //调用所有注册对象的方法
                  }
              }
           }
       }
    }

    // 警报器
    public class Alarm {
       public void MakeAlert(int param) {
           Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：", param);
       }
    }

    // 显示器
    public class Display {
       public static void ShowMsg(int param) { //静态方法
           Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", param);
       }
    }
    
    class Program {
       static void Main() {
           Heater heater = new Heater();
           Alarm alarm = new Alarm();

           heater.BoilEvent += alarm.MakeAlert;    //注册方法
           heater.BoilEvent += (new Alarm()).MakeAlert;   //给匿名对象注册方法
           heater.BoilEvent += Display.ShowMsg;       //注册静态方法

           heater.BoilWater();   //烧水，会自动调用注册过对象的方法
       }
    }


}

 

.Net Framework中的委托与事件

尽管上面的范例很好地完成了我们想要完成的工作，但是我们不仅疑惑：为什么.Net Framework 中的事件模型和上面的不同？为什么有很多的EventArgs参数？

在回答上面的问题之前，我们先搞懂 .Net Framework的编码规范：

  • 委托类型的名称都应该以EventHandler结束。
  • 委托的原型定义：有一个void返回值，并接受两个输入参数：一个Object 类型，一个 EventArgs类型(或继承自EventArgs)。
  • 事件的命名为 委托去掉 EventHandler之后剩余的部分。
  • 继承自EventArgs的类型应该以EventArgs结尾。

再做一下说明：

  1. 委托声明原型中的Object类型的参数代表了Subject，也就是监视对象，在本例中是 Heater(热水器)。回调函数(比如Alarm的MakeAlert)可以通过它访问触发事件的对象(Heater)。
  2. EventArgs 对象包含了Observer所感兴趣的数据，在本例中是temperature。

上面这些其实不仅仅是为了编码规范而已，这样也使得程序有更大的灵活性。比如说，如果我们不光想获得热水器的温度，还想在Observer端(警报器或者显示器)方法中获得它的生产日期、型号、价格，那么委托和方法的声明都会变得很麻烦，而如果我们将热水器的引用传给警报器的方法，就可以在方法中直接访问热水器了。

现在我们改写之前的范例，让它符合 .Net Framework 的规范：

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

namespace Delegate {
    // 热水器
    public class Heater {
       private int temperature;
       public string type = "RealFire 001";       // 添加型号作为演示
       public string area = "China Xian";         // 添加产地作为演示
       //声明委托
       public delegate void BoiledEventHandler(Object sender, BoiledEventArgs e);
       public event BoiledEventHandler Boiled; //声明事件

       // 定义BoiledEventArgs类，传递给Observer所感兴趣的信息
       public class BoiledEventArgs : EventArgs {
           public readonly int temperature;
           public BoiledEventArgs(int temperature) {
              this.temperature = temperature;
           }
       }

       // 可以供继承自 Heater 的类重写，以便继承类拒绝其他对象对它的监视
       protected virtual void OnBoiled(BoiledEventArgs e) {
           if (Boiled != null) { // 如果有对象注册
              Boiled(this, e);  // 调用所有注册对象的方法
           }
       }
       
       // 烧水。
       public void BoilWater() {
           for (int i = 0; i <= 100; i++) {
              temperature = i;
              if (temperature > 95) {
                  //建立BoiledEventArgs 对象。
                  BoiledEventArgs e = new BoiledEventArgs(temperature);
                  OnBoiled(e);  // 调用 OnBolied方法
              }
           }
       }
    }

    // 警报器
    public class Alarm {
       public void 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();
       }
    }

    // 显示器
    public class Display {
       public static void 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();
       }
    }

    class Program {
       static void Main() {
           Heater heater = new Heater();
           Alarm alarm = new Alarm();

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

           heater.BoilWater();   //烧水，会自动调用注册过对象的方法
       }
    }
}

 

总结

在本文中我首先通过一个GreetingPeople的小程序向大家介绍了委托的概念、委托用来做什么，随后又引出了事件，接着对委托与事件所产生的中间代码做了粗略的讲述。

在第二个稍微复杂点的热水器的范例中，我向大家简要介绍了 Observer设计模式，并通过实现这个范例完成了该模式，随后讲述了.Net Framework中委托、事件的实现方式。

希望这篇文章能给你带来帮助。

分享到：
| ASP.NET 2.0 绑定高级技巧
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    C#中的委托和事件(完整版)

    详细讲述了C#中委托和事件的语法及其使用方法，用程序例子深入浅出的讲述了不同的使用方法和这些使用方法的优劣。

    C#中委托与事件的区别

    委托 和 事件在 .Net Framework中的应用非常广泛，然而，较好地理解委托和事件。对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿，过了这个槛的人，觉得真是太容易了，而没有过去的人每次见到委托和事件...

    C#中委托和事件

    介绍C#语言的中委托和事件基础知识，希望能对大家有所帮助。 介绍C#语言的中委托和事件基础知识，希望能对大家有所帮助。

    C#中委托和事件，无多播委托

    帮你理解C#中委托和事件，更容易跨过C#门槛后步步高升，努力加技巧，更方便你的进步

    C#中委托和事件.pdf

    C#中委托和事件.pdf

    对C#中委托和事件很生动的描述

    对C#中委托和事件很生动的描述，让您对这块内容有深入的了解。

    C# 中委托和事件的例子DelegateAndEventDemo

    C# 中委托和事件的例子DelegateAndEventDemo 京华志&精华志出品 希望大家互相学习，互相进步 支持CSDN 支持微软 主要包括C# ASP.NET SQLDBA 源码 毕业设计 开题报告 答辩PPT等

    C#中委托和事件 方法的使用

    C# 中的委托和事件 将方法作为方法的参数 将方法绑定到委托 ...事件和委托的编译代码 委托、事件与Observer设计模式 Observer设计模式简介 实现范例的Observer设计模式 .Net Framework中的委托与事件

    C# 中委托和事件的例子

    //声明一个事件 public void Click() { if (ClickEvent != null) { Console.WriteLine("MyButton:我被单击了"); ClickEvent(this, null); } } } public class MyForm { public MyButton myButton = ...

    C#的委托和事件详解

    委托 和 事件在 .Net Framework中的应用非常广泛，然而，较好地理解委托和事件对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿，过了这个槛的人，觉得真是太容易了，而没有过去的人每次见到委托和事件就...

    C# 委托和事件 （详细讲解）

    C# 讲解委托和事件的好文章集合。 包括： C# 委托妙文 C# 委托和事件 C# 委托使用方法 C# WndProc的使用方法 文档内有详细代码，您一定可以用它学会委托和事件！

    C#编程语言中的委托和事件

    本文档详细的讲述了C#中委托和事件的原理和使用方法

    c#中委托和事件例子

    很实用的例子，简单易懂

    C#中的委托和事件(续)

    C#，中的委托，和事件，(续) C#，中的委托，和事件，(续) C#，中的委托，和事件，(续) C#，中的委托，和事件，(续) C#，中的委托，和事件，(续) C#，中的委托，和事件，(续) C#，中的委托，和事件，(续) C#，中的...

    C#--委托和事件

    学习C#毕竟之路，对事件编程，入门级介绍，全面而且细致

    C#的委托与事件的示例代码

    介绍C#中委托与事件的示例代码，阐述了委托和事件的密切联系，展现C#的迷人魅力。

    c#中委托，事件和BeginInvoke在进程间传递消息的作用

    使用委托，事件和BeginInvoke从另外一个cs文件向form.cs文件传递数据，并把数据赋值给窗体控件

Magicbox
Global site tag (gtag.js) - Google Analytics