C#委托和事件

C#委托及事件

在C#中，委托（delegate）是一种引用类型，在其他语言中，与委托最接近的是函数指针，但委托不仅存储对方法入口点的引用，还存储对用于调用方法的对象实例的引用。

首先，看下面的示例程序，在C++中使用函数指针。

int Max(int x,int y)  //求两个数的最大值

{

return x>y?x:y;

}

int Min(int x,int y)  //求两个数的最小值

{

return x

}

上面两个函数的特点是：函数的返回值类型及参数列表都一样。那么，我们可以使用函数指针来指代这两个函数，并且可以将具体的指代过程交给用户，这样，可以减少用户判断的次数。

下面我们可以建立一个函数指针，将指向任意一个方法，代码如下所示：

int (*p)(int,int);  //定义一个函数指针，并声明该指针可以指向的函数的返回值为int类型，参数列表中包括两个int类型的参数

p=max;  //让指针p指向Max函数

c=(*p)(5,6);  //利用指针调用Max

使用指针的方便之处就在于，当前时刻可以让指针p指向Max，在后面的代码中，我们还可以利用指针p再指向Min函数，但是不论p指向的是谁，调用p时的形式都一样，这样可以很大程度上减少判断语句的使用，使代码的可读性增强！

在C#中，我们可以使用委托（delegate）来实现函数指针的功能，也就是说，我们可以像使用函数指针一样，在运行时利用delegate动态指向具备相同签名的方法（所谓的方法签名，是指一个方法的返回值类型及其参数列表的类型）。

使用委托（delegate）

委托是C#中新加入的一个类型，可以把它想作一个和Class类似的一种类型，和使用类相似，使用一个委托时，需要两个步骤，首先你要定义一个委托，就像是定义一个类一样；然后，你可以创建一个或多个该委托的实例。

委托的建立

建立委托（delegate），过程有点类似于建立一个函数指针。过程如下：

1. 建立一个委托类型，并声明该委托可以指向的方法的签名（函数原型）

delegate int MyDelegate(int a,int b);

2.建立一个委托类的实例，并指向要调用的方法

//利用委托类的构造方法指定，这是最为常见的一种方式

MyDelegate md=new MyDelegate(Max);

//利用自动推断方式来指明要调用的方法，该形式更类型于函数指针

MyDelegate md=Max;

3.利用委托类实例调用所指向的方法

int c=md(4,5);

例:

namespace Delegate {

public delegate void GreetingDelegate(string name);   //定义委托，它定义了可以代表的方法的类型

public class GreetingManager

{

     //在GreetingManager类的内部声明delegate1变量

     public GreetingDelegate delegate1;  

public void GreetPeople(string name) 

     {

         if(delegate1!=null)

{     //如果有方法注册委托变量

           delegate1(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) 

{

        GreetingManager gm = new  GreetingManager();

     gm.delegate1 = EnglishGreeting;

     gm.delegate1 += ChineseGreeting;

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

        }

}

输出为：

Morning, Jimmy Zhang

早上好, Jimmy Zhang

事件的由来

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

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

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

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

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

public class GreetingManager

{
        public event GreetingDelegate MakeGreet;   //这一次我们在这里声明一个事件
       public void GreetPeople(string name) 

{
         MakeGreet(name);
     }
}

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

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

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

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

组合范例

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

namespace Delegate {
 // 热水器
     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();   //烧水，会自动调用注册过对象的方法
        }
     }
}
输出为：
Alarm：嘀嘀嘀，水已经 96 度了：
Alarm：嘀嘀嘀，水已经 96 度了：
Display：水快烧开了，当前温度：96度。