事件（event）是一个非常重要的概念，我们的程序时刻都在触发和接收着各种事件：鼠标点击事件，键盘事件，以及处理操作系统的各种事件。所谓事件就是由某个对象发出的消息。比如用户按下了某个按钮，某个文件发生了改变，socket上有数据到达。触发事件的对象称作发送者（sender），捕获事件并且做出响应的对象称作接收者（receiver），一个事件可以存在多个接受者。
在异步机制中，事件是线程之间进行通信的一个非常常用的方式。比如：用户在界面上按下一个按钮，执行某项耗时的任务。程序此时启动一个线程来处理这个任务，用户界面上显示一个进度条指示用户任务执行的状态。这个功能就可以使用事件来进行处理。可以将处理任务的类作为消息的发送者，任务开始时，发出“TaskStart”事件，任务进行中的不同时刻发出“TaskDoing”事件，并且携带参数说明任务进行的比例，任务结束的时候发出“TaskDone”事件，在画面中接收并且处理这些事件。这样实现了功能，并且界面和后台执行任务的模块耦合程度也是最低的。
具体说C#语言，事件的实现依赖于“代理”（delegate）的概念，先了解一下代理。
代理（delegate）
delegate是C#中的一种类型，它实际上是一个能够持有对某个方法的引用的类。与其它的类不同，delegate类能够拥有一个签名（signature），并且它只能持有与它的签名相匹配的方法的引用。它所实现的功能与C/C++中的函数指针十分相似。它允许你传递一个类A的方法m给另一个类B的对象，使得类B的对象能够调用这个方法m。但与函数指针相比，delegate有许多函数指针不具备的优点。首先，函数指针只能指向静态函数，而delegate既可以引用静态函数，又可以引用非静态成员函数。在引用非静态成员函数时，delegate不但保存了对此函数入口指针的引用，而且还保存了调用此函数的类实例的引用。其次，与函数指针相比，delegate是面向对象、类型安全、可靠的受控（managed）对象。也就是说，runtime能够保证delegate指向一个有效的方法，你无须担心delegate会指向无效地址或者越界地址。
实现一个delegate是很简单的，通过以下3个步骤即可实现一个delegate：
1． 声明一个delegate对象，它应当与你想要传递的方法具有相同的参数和返回值类型。
2． 创建delegate对象，并将你想要传递的函数作为参数传入。
3． 在要实现异步调用的地方，通过上一步创建的对象来调用方法。
下面是一个简单的例子：
public class MyDelegateTest
{
// 步骤1，声明delegate对象
public delegate void MyDelegate(string name);
// 这是我们欲传递的方法，它与MyDelegate具有相同的参数和返回值类型
public static void MyDelegateFunc(string name)
{
Console.WriteLine("Hello, {0}", name);
}
public static void Main ()
{
// 步骤2，创建delegate对象
MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);
// 步骤3，调用delegate
md("sam1111");
}
}
输出结果是：Hello, sam1111
下面我们来看看事件是如何处理的：
在C#中处理事件
C#中的事件处理实际上是一种具有特殊签名的delegate，象下面这个样子：
public delegate void MyEventHandler(object sender, MyEventArgs e);
其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从System.EventArgs类派生。当然，如果你的事件不含参数，那么可以直接用System.EventArgs类作为参数。
就是这么简单，结合delegate的实现，我们可以将自定义事件的实现归结为以下几步：
1． 定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。
2． 定义事件参数类，此类应当从System.EventArgs类派生。如果事件不带参数，这一步可以省略。
3． 定义事件处理方法，它应当与delegate对象具有相同的参数和返回值类型。
4． 用event关键字定义事件对象，它同时也是一个delegate对象。
5． 用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。
6． 在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是OnEventName。
7． 在适当的地方调用事件触发方法触发事件。
下面是一个简单的例子：
using System;
public class EventTest
{
// 步骤1，定义delegate对象
public delegate void MyEventHandler(object sender, System.EventArgs e);
// 步骤2省略
public class MyEventCls
{
// 步骤3，定义事件处理方法，它与delegate对象具有相同的参数和返回值类// 型
public void MyEventFunc(object sender, System.EventArgs e)
{
Console.WriteLine("My event is ok!");
}
}
// 步骤4，用event关键字定义事件对象
private event MyEventHandler myevent;
private MyEventCls myecls;
public EventTest()
{
myecls = new MyEventCls();
// 步骤5，用+=操作符将事件添加到队列中
this.myevent += new MyEventHandler(myecls.MyEventFunc);
}
// 步骤6，以调用delegate的方式写事件触发函数
protected void OnMyEvent(System.EventArgs e)
{
if(myevent != null)
myevent(this, e);
}
public void RaiseEvent()
{
EventArgs e = new EventArgs();
// 步骤7，触发事件
OnMyEvent(e);
}
public static void Main()
{
EventTest et = new EventTest();
Console.Write("Please input 'a':");
string s = Console.ReadLine();
if(s == "a")
{
et.RaiseEvent();
}
else
{
Console.WriteLine("Error");
}
}
}
输出结果如下，黑体为用户的输入：
Please input ‘a’: a
My event is ok!
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
C#代表元及事件触发 |
|
|
事件简介：
任何进行过图形用户界面开发的编程人员都会知道事件的概念。当用户在使用程序的时候，用户必然要和程序进行一定的交互。比如当用户点击窗体上的一个按钮后，程序就会产生该按钮被点击的事件，并通过相应的事件处理函数来响应用户的操作。这样用户的直观感觉就是程序执行了我要求的任务了。当然，事件并不一定是在和用户交互的情况下才会产生的，系统的内部也会产生一些事件并请求处理的，比如时钟事件就是一个很好例子。不过要介绍C#中的事件处理机制（扩展到更广的范围便是整个.Net框架），我们首先得明白一个叫"委托"的概念。
C#中的委托：
委托，顾名思义，就是中间代理人的意思。C#中的委托允许你将一个对象中的方法传递给另一个能调用该方法的类的某个对象。你可以将类A中的一个方法m（被包含在某个委托中了）传递给一个类B，这样类B就能调用类A中的方法m了。同时，你还可以以静态（static）的方式或是实例（instance）的方式来传递该方法。所以这个概念和C++中的以函数指针为参数形式调用其他类中的方法的概念是十分类似的。
委托的概念首先是在Visual J++中被提出来的，现在C#也应用了委托的概念，这也可谓是"拿来主义"吧。C#中的委托是通过继承System.Delegate中的一个类来实现的，下面是具体的步骤：
1． 声明一个委托对象，其参数形式一定要和你想要包含的方法的参数形式一致。
2． 定义所有你要定义的方法，其参数形式和第一步中声明的委托对象的参数形式必须相同。
3． 创建委托对象并将所希望的方法包含在该委托对象中。
4． 通过委托对象调用包含在其中的各个方法。
以下的C#代码显示了如何运用以上的四个步骤来实现委托机制的：
using System;
file://步骤1： 声明一个委托对象
public delegate void MyDelegate(string input);
file://步骤2:：定义各个方法，其参数形式和步骤1中声明的委托对象的必须相同
class MyClass1{
public void delegateMethod1(string input){
Console.WriteLine(
"This is delegateMethod1 and the input to the method is {0}",
input);
}
public void delegateMethod2(string input){
Console.WriteLine(
"This is delegateMethod2 and the input to the method is {0}",
input);
}
}
file://步骤3：创建一个委托对象并将上面的方法包含其中
class MyClass2{
public MyDelegate createDelegate(){
MyClass1 c2=new MyClass1();
MyDelegate d1 = new MyDelegate(c2.delegateMethod1);
MyDelegate d2 = new MyDelegate(c2.delegateMethod2);
MyDelegate d3 = d1 + d2;
return d3;
}
}
file://步骤4：通过委托对象调用包含在其中的方法
class MyClass3{
public void callDelegate(MyDelegate d,string input){
d(input);
}
}
class Driver{
static void Main(string[] args){
MyClass2 c2 = new MyClass2();
MyDelegate d = c2.createDelegate();
MyClass3 c3 = new MyClass3();
c3.callDelegate(d,"Calling the delegate");
}
}
C#中的事件处理函数：
C#中的事件处理函数是一个具有特定参数形式的委托对象，其形式如下：
public delegate void MyEventHandler(object sender, MyEventArgs e);
其中第一个参数（sender）指明了触发该事件的对象，第二个参数（e）包含了在事件处理函数中可以被运用的一些数据。上面的MyEventArgs类是从EventArgs类继承过来的，后者是一些更广泛运用的类，如MouseEventArgs类、ListChangedEventArgs类等的基类。对于基于GUI的事件，你可以运用这些更广泛的、已经被定义好了的类的对象来完成处理；而对于那些基于非GUI的事件，你必须要从EventArgs类派生出自己的类，并将所要包含的数据传递给委托对象。下面是一个简单的例子：
public class MyEventArgs EventArgs{
public string m_myEventArgumentdata;
}
在事件处理函数中，你可以通过关键字event来引用委托对象，方法如下：
public event MyEventHandler MyEvent;
现在，我们来创建两个类，通过这两个类我们可以知道C#完成事件处理的机制是如何工作的。在我们的实例中，A类将提供事件的处理函数，并在步骤3中创建委托对象同时将事件处理函数包含在其中，同上所述，事件处理函数的参数形式必须和委托对象的参数形式相一致。然后，A类将委托对象传递给B类。当B类中的事件被触发后，A类中的事件处理函数就相应的被调用了。下面是示例代码：
using System;
file://步骤1：声明委托对象
public delegate void MyHandler1(object sender,MyEventArgs e);
public delegate void MyHandler2(object sender,MyEventArgs e);
file://步骤2：创建事件处理函数的方法
class A{
public const string m_id="Class A";
public void OnHandler1(object sender,MyEventArgs e){
Console.WriteLine("I am in OnHandler1 and MyEventArgs is {0}",
e.m_id);
}
public void OnHandler2(object sender,MyEventArgs e){
Console.WriteLine("I am in OnHandler2 and MyEventArgs is {0}",
e.m_id);
}
file://步骤3：创建委托对象，并事件处理函数包含在其中同时设置好将要触发事件的对象
public A(B b){
MyHandler1 d1=new MyHandler1(OnHandler1);
MyHandler2 d2=new MyHandler2(OnHandler2);
b.Event1 +=d1;
b.Event2 +=d2;
}
}
file://步骤4：通过委托对象（也就是触发事件）来调用被包含的方法
class B{
public event MyHandler1 Event1;
public event MyHandler2 Event2;
public void FireEvent1(MyEventArgs e){
if(Event1 != null){
Event1(this,e);
}
}
public void FireEvent2(MyEventArgs e){
if(Event2 != null){
Event2(this,e);
}
}
}
public class MyEventArgs EventArgs{
public string m_id;
}
public class Driver{
public static void Main(){
B b= new B();
A a= new A(b);
MyEventArgs e1=new MyEventArgs();
MyEventArgs e2=new MyEventArgs();
e1.m_id ="Event args for event 1";
e2.m_id ="Event args for event 2";
b.FireEvent1(e1);
b.FireEvent2(e2);
}
}
C#中的GUI的事件处理函数：
完成GUI下的事件处理函数的基本方法和上面介绍的并没有什么多大区别，下面我们就通过上面的方法来完成一个简单的实例程序。该实例程序的主类MyForm类是从Form类继承过来的。通过观察整段代码和相关的注解，你可以发现我们并没有给它声明委托对象并通过event关键字来引用该委托对象，那是因为GUI控件早就帮我们做好了该项工作，其委托对象是System.EventHandler。然而，我们还是要为各个控件定义方法（也就是事件的处理函数）并将它们包含在创建好的委托对象（System.EventHandler）中。那样，在用户和程序进行交互的时候，相应的事件处理函数就会被触发。具体代码如下：
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
public class MyForm Form{
private Button m_nameButton;
private Button m_clearButton;
private Label m_nameLabel;
private Container m_components = null;
public MyForm(){
initializeComponents();
}
private void initializeComponents(){
m_nameLabel=new Label();
m_nameButton = new Button();
m_clearButton = new Button();
SuspendLayout();
m_nameLabel.Location=new Point(16,16);
m_nameLabel.Text="Click NAME button, please";
m_nameLabel.Size=new Size(300,23);
m_nameButton.Location=new Point(16,120);
m_nameButton.Size=new Size(176, 23);
m_nameButton.Text="NAME";
file://创建委托对象，包含方法并将委托对象赋给按钮的Click事件
m_nameButton.Click += new System.EventHandler(NameButtonClicked);
m_clearButton.Location=new Point(16,152);
m_clearButton.Size=new Size(176,23);
m_clearButton.Text="CLEAR";
file://创建委托对象，包含方法并将委托对象赋给按钮的Click事件
m_clearButton.Click += new System.EventHandler(ClearButtonClicked);
this.ClientSize = new Size(292, 271);
this.Controls.AddRange(new Control[] {m_nameLabel,
m_nameButton,
m_clearButton});
this.ResumeLayout(false);
}
file://定义方法（事件的处理函数），其参数形式必须和委托对象的一致
private void NameButtonClicked(object sender, EventArgs e){
m_nameLabel.Text=
"My name is john, please click CLEAR button to clear it";
}
private void ClearButtonClicked(object sender,EventArgs e){
m_nameLabel.Text="Click NAME button, please";
}
public static void Main(){
Application.Run(new MyForm());
}
}
小结：
这样，我就向大家初步介绍了C#中的事件处理机制。通过本文，希望能使大家对C#中的事件处理机制乃至整个.Net框架的事件处理机制有个大致的了解，同时还希望大家能明确"委托"这样的较新的概念。最后还要指出的是，如果你是在用Visual Studio的集成开发环境进行开发的话，那么各个GUI控件会自动帮你生成相关的许多代码，但是知道了其内部的工作机制的话总归是有很大益处的，对吗？