事件处理程序是基于“委托”机制运行的。

1.委托

（1）委托的定义和使用

有时需要将一个函数作为另一个函数的参数，这时就要用到委托（Delegate）机制。例如设计一个马戏表演函数：

//定义委托

delegate void AnimalPlay(string name);

static void CircusStart(AnimalPlay animalPlay, string name){ animalPlay(name); }

这里AnimalPlay是委托的类型，而animalPlay是委托，调用时可以：

//把函数DogPlay()转换为AnimalPlay 型委托

AnimalPlay deleDogPlay = new AnimalPlay(DogPlay);

//把委托deleDogPlay 传给函数CircusStart()

CircusStart(deleDogPlay, "Good evening");

函数CircusStart()的第一个参数是动物表演函数，传给它什么样的函数，它就进行什么动物的表演，C#中函数的参数都有严格的类型，怎么表示这种“函数参数”的类型呢？这就需要用到委托（Delegate）。委托相当于定义了一种“函数类型”，规定了这类函数的参数类型和返回值类型。委托用关键字delegate 声明：

上面的语句定义了一种名为AnimalPlay的委托，与它匹配的函数必须具有相同的签名。当需要把某个函数作为参数时，可以先把它转换为委托实例，然后把得到委托实例为参数传递给调用它的函数，可以看出委托实例deleDogPlay 实际上相当于函数DogPlay()的别名：

在新版本的.NET 中，可以直接传递函数名称，省去把函数转换为委托实例的过程。.Net 编译器会暗中把DogPlay()函数转换为AnimalPlay 委托的实例，从而简化编程过程。例如：

delegate void AnimalPlay(string name);

static void CircusStart(AnimalPlay animalPlay, string name){ animalPlay(name); }

static void DogPlay(string greetings)

{…}

static void Main(string[] args)

{

//直接传递DogPlay()函数

CircusStart(DogPlay, "Snoopy");

}

综上所述，利用委托可以实现以函数为参数，提高程序的通用性。实际上委托也是由类实现的，当我们创一个从System.Delegate 派生出来的类，类中有一个调用列表，列表中包含着指向被委托函数的引用。与C++指针相比，委托是一种类型安全的方式，并能实现很多其它功能。

（2）多播委托

可以向一个委托实例中注册多个函数，这种包含多个函数的委托实例称为多播委托（Multicast Delegate），那些被委托的函数的引用都存储在多播委托的调用列表中，当调用多播委托时，会按一定顺序依次调用列表中的所有函数。例如：

static void Main(string[] args) {

//多播委托 AnimalPlay animalsPlay = new AnimalPlay(DogPlay);

animalsPlay += new AnimalPlay(CatPlay);

animalsPlay += new AnimalPlay(LionPlay);

CircusStart(animalsPlay,"Good morning"); }

向多播委托实例中注册函数animalsPlay += new AnimalPlay(CatPlay);，注销函数animalsPlay -= new AnimalPlay(CatPlay);。

多播委托的返回值一般为void，如果为非void 类型，多播委托可能有多个返回值（因为会调用多个函数），这时多播委托将返回最后一个方法的返回值。但实际中不推荐这样应用，因为这些方法的调用顺序未正式定义，因此应避免编写依赖于特定调用顺序的代码。

（3）匿名函数

创建委托实例时不仅可以使用已有的函数，而且可以直接使用匿名函数（Anonymous Function）。看下面这个例子：

public delegate void EatFoodDelegate(Person p);

public class Person

{  public string Name { get; set; }

public int Age { get; set; }

public Person(string name, int age)

{   Name = name;  Age = age;   }

public EatFoodDelegate eatFoodDelegate;

public void eating()

{  if (eatFoodDelegate != null)

{  eatFoodDelegate(this); }

}

}

static void Main(string[] args)

{   Person chinesePerson = new Person("小明",25);

//方式一：将用实际函数创建的委托实例注册到委托，早期C#常用方法

chinesePerson.eatFoodDelegate += new EatFoodDelegate(chineseEat);

chinesePerson.eating();

Person englishPerson = new Person("Ivan",25);

//方式二：直接将匿名函数赋值给一个委托实例

englishPerson.eatFoodDelegate = delegate (Person p)

{Console.WriteLine("I'm {0},I am {1} , I eat MianBao", p.Name, p.Age);};

englishPerson.eating(); }

}

static void chineseEat(Person p)

{Console.WriteLine("{0}, {1}岁,我吃馒头",p.Name,p.Age);}

(4) Lambda表达式

C#3.0 引入了匿名函数——Lambda 表达式，有了Lambda 表达式，可以用非常简洁的方式定义匿名函数。例如：

englishPerson.eatFoodDelegate = delegate (Person p)

{Console.WriteLine("I'm {0},I am {1} , I eat MianBao", p.Name, p.Age);};

可以写成：

englishPerson.eatFoodDelegate =(Person p)=>

{Console.WriteLine("I'm {0},I am {1} , I eat MianBao", p.Name, p.Age);}

Lambda表达式是一种简洁的定义匿名函数的方法，用Lambda表达式构造的匿名函数看上去就像一个计算表达式，它使用“=>”符号来连接参数和事件处理代码，极大的增强了匿名函数的可读性。例如将匿名函数赋值给一个Integrand委托的实例f3：

不但如此，我们还可以省略Lambda 表达式参数列表中的参数类型和“return”关键字, 和普通方法一样，Lambda表达式可以没有参数，也可以有多个参数，当无参数或有多个参数时，“=>”左边必须有()，当仅有一个参数时，可以省略：

Integrand f3=()=>{3*2+5};

Integrand f3=x=>{3*x+5};

Integrand f3=(x,y)=>{3*x+5*y};

（5）宽松委托

从C#3.0 开始，出现了更为宽松的委托，被委托函数的参数类型可以比委托要求的更大、更宽泛，被委托函数的返回值类型可以比委托要求的更小、更精确。

Public class Animal{}

Public class Cat:Animal{}

Public delegate Animal AnimalHandler(Animal a);

Public static Cat CatPlay(Object o)

{return null;}

则下面的语句是合法的：

AnimalHandler handler=new AnimalHandler(CatPlay);

被委托函数的参数类型可以是委托参数的基类（逆变），被委托函数的返回值类型可以是委托返回值的派生类（协变）。

2.事件处理机制

（1）.NET事件概述

Windows 应用程序是事件驱动的，当一个窗体应用程序启动后，系统就不停的检测是否有事件发生，如果检测到事件，就执行对应的事件处理程序。单击鼠标、敲击键盘都会触发事件（Raise Event），系统都会找到并执行对应的事件处理程序。把触发事件的对象称为事件的发送者（Event Sender），响应事件的对象称为事件的接收者（Event Receiver）。例如一个窗体中按钮触发事件的过程，按钮就是事件的发送者，事件的接收者是窗体（因为事件处理程序是窗体的函数成员）。

Public partial class Form1:Form

{ private void btnOK_Click(object sender,EventArgs e)

{ MessageBox.Show(“Hello”);}  }

当事件发生时，系统是如何找到对应的事件处理程序的呢，当然不可能根据事件处理程序的名称，因为.NET程序员要以随意定义事件处理程序的名称。实际上，只能是根据事件的名称来寻找相应的事件处理程序。.NET 中预定义了许多种专门用于事件的委托类型，比如EventHandler、KeyEventHandler、MouseEventHandler 等

public delegate void EventHandler(object sender, EventArgs e);

EventHandler是一个很常用的事件委托，这个委托接收两个参数，一个是发送事件的发送者，一个是事件本身的参数。Control类，就会发现该类定义了大量事件成员，如图所示：

其中有我们很熟悉的Click、DoubleClick、KeyPress等。

public event EventHandler Click;

public event EventHandler DoubleClick;

public event EventHandler KeyPress;

……

可出看出，事件实际上就是一个委托实例而已，事件和委托的关系，就是对象和类的关系，事件和方法、变量、属性等一样，都是控件类的成员，只是声明事件时必须用event关键字。默认情况下，系统已经将窗体程序的各种行为，与定义的系统事件一一对应起来了，只要有一种预定义的行为发生，则会触发相应的事件，然后就会调用事件的处理程序。将自定义的处理程序添加到事件，非常简单，就是将一个函数注册到委托实例的过程，例如：

btnOK.Click += new System.EventHandler(this.btnOK_Click);

此后，用户函数的引用就被保存在事件btnOK.Click的调用列表中，系统通过事件的调用列表，就能轻松地找到对应的事件处理程序。注意：event关键字的作用是把事件封装起来，即只能在声明事件的类的内部触发事件，在类外部只能注册事件而不能触发事件。比如对于在btnOK里声明的Click事件，语句“btnOK.Click()”只能出现在btnOK类内部，不能出现在类外部。可以在一个事件中注册多个事件处理程序。当事件发生时，系统就会依次调用事件中所有的处理程序。

总之，.NET就是通过委托机制把系统和应用程序中的事件处理程序联系起来的。

（2）自定义事件

要创建一个事件驱动的程序需要下面的步骤：

1．声明关于事件的委托；

2．声明事件；

3．编写触发事件的函数；

4．创建事件处理程序；

5．注册事件处理程序；

6．在适当的条件下触发事件

按照这6个步骤，.NET程序员可以自定义事件及其处理程序。例如

//事件发送者

Class Dog{

//1.声明关于事件的委托

public delegate void AlarmEventHandler(object sender,EventArgs e);

//2.声明事件

public event AlarmEventHandler Alarm;

//3.编写引发事件的函数

public void OnAlarm()

{  //先判断有无事件程序，然后再调用

if(this.Alarm!=null) this.Alarm(this,new EventArgs());}

}

//事件接收者

Class Host

{

//4.编写事件处理程序

void HostHandleAlarm(object sender,EventArgs e)

{  Console.WriteLine(“主要：抓住了小偷”);}

//5.注册事件处理程序

public Host(Dog dog)

{  dog.Alarm+=new Dog.AlarmEventHandler(HostHandleAlarm);}

}

//6.现在来触发事件

class Program

{

static void Main(string [] args)

{Dog dog=new Dog();

Host host=new Host(dog);

DateTime now = new DateTime(2011,12,31,23,59,55);

DateTime midnight = new DateTime(2012, 1, 1, 0, 0, 0);

Console.WriteLine("时间一秒一秒地流逝，等待午夜的到来... ");

while(true)

{

Console.WriteLine(“当前时间：”+Now);

//午夜零点小偷到达,看门狗引发Alarm 事件

if(now == midnight)

{  Console.WriteLine("\n 月黑风高, 小偷悄悄地摸进了主人的屋内...");

//引发事件

Console.WriteLine("\n 狗报警: 有小偷进来了,汪汪~~~~~~~");

dog.OnAlarm();

break;   }

System.Threading.Thread.Sleep(1000); //程序暂停一秒

now = now.AddSeconds(1); //时间增加一秒

}  //while

} //Main

} //program

当午夜时分小偷到达时，dog 调用dog.OnAlarm()函数，从而触发Alarm 事件，于是系统找到并执行了注册在Alarm 事件中的事件处理程序HostHandleAlarm()。引发事件的代码（即OnAlarm()函数）和事件处理程序是分离的，引发事件的代码只管调用“Alarm()”，而事件处理程序另外独立定义，它们之间通过事件Alarm 联系起来。事件处理程序接受两个参数，一个是事件的发送者sender，一个是事件参数e，事件参数用于在发送者和接收者之间传递信息。.NET 提供了100 多个事件参数类，它们都继承于EventArgs 类。

一般情况下，使用.NET自带的类足够了，但为了讲清原理，来自定义一个事件参数类。

public class AlarmEventArgs : EventArgs

{  public int numberOfThief;

public AlarmEventArgs(int numberValue)

{ numberOfThief= numberValue;}

}

class Dog

{

//1.声明关于事件的委托；

public delegate void AlarmEventHandler(object sender, AlarmEventArgs e);

//2.声明事件；

public event AlarmEventHandler Alarm;

//3.编写引发事件的函数，注意多了个参数；

public void OnAlarm(AlarmEventArgs e)

{  if(this.Alarm != null)

this.Alarm(this, e);  }

}

//事件接收者

class Host

{

//４.编写事件处理程序，参数中包含着numberOfThief 信息

//如果只有一个小偷，主人抓住小偷；如果小偷多于一个，主人报警

void HostHandleAlarm (object sender, AlarmEventArgs e)

if (e.numberOfThief <= 1)

{  Console.WriteLine("主人: 抓住了小偷！");}

else

｛Console.WriteLine("主人:打110报警,我家来了{0}个小偷!", e.numberOfThief);}

//5.注册事件处理程序

public Host(Dog dog)

{ dog.Alarm += new Dog.AlarmEventHandler(HostHandleAlarm);}

}

//6.现在来触发事件

class Program

{

static void Main(string[] args)

{ Dog dog = new Dog();

Host host = new Host(dog);

DateTime now = new DateTime(2011,12,31,23,59,55);

DateTime midnight = new DateTime(2012, 1, 1, 0, 0, 0);

Console.WriteLine("时间一秒一秒地流逝,等待午夜的到来... ");

while (true)

{  Console.WriteLine("当前时间: " + now);

//午夜零点小偷到达,看门狗引发Alarm 事件

if(now == midnight)

{ Console.WriteLine("\n 月黑风高的午夜，小偷悄悄地摸进了主人的屋内...");

//引发事件

Console.WriteLine("\n 狗报警: 有小偷进来了,汪汪~~~~~~~");

AlarmEventArgs e = new AlarmEventArgs(3); //创建事件参数

dog.OnAlarm(e);

break;  }

System.Threading.Thread.Sleep(1000); //程序暂停一秒

now = now.AddSeconds(1); //时间增加一秒

}

}

}