C#委托与事件

委托是一种引用方法的类型,跟接口一样允许设计器把方法的定义跟实现分离。事件是使用委托来为触发时将调用的方法提供类型安全的封装,可以说事件是委托的一种特例。
委托和事件特点如下:
委托具有以下特点:
委托类似于 C++ 函数指针,但它是类型安全的。
委托允许将方法作为参数进行传递。
委托可用于定义回调方法。
委托可以链接在一起。
方法不需要与委托签名精确匹配。

事件具有以下特点:
事件是类用来通知对象需要执行某种操作的方式。
尽管事件在其他时候(如信号状态更改)也很有用,事件通常还是用在图形用户界面中。
事件通常使用委托事件处理程序进行声明。
事件可以调用匿名方法来替代委托。

其实,你可以在msdn中找到答案,微软已经给予了深刻的解释
C#里的委托和事件实现Observer
2007/01/31 下午 09:53

一、委托的简介

1、委托的声明:

<access modifier> delegate <returnType> HandlerName ([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、定义委托,就是你让主管小王监视员工小张。

如果这三个要素都满足的话,则你就写出了一个完整事件的处理。 
委托是一种安全地封装方法的类型,它与 C 和 C++ 中的函数指针类似。委托的类型由委托的名称定义。下面的示例声明了一个名为 Del 的委托,该委托可以封装一个采用字符串作为参数并返回 void 的方法。(以下只是声明了一个委托类型,void和()里面的内容只是针对要委托的方法的定制说明,但委托就是一个类)。
//委托声明(相当一个类的声明,但是要对指向的方法做说明,如返回值,参数说明)
public delegate void MyDelegate (string message);
//为委托创建一个方法.
public static void DelegateMethod(string message)
{
System.Console.WriteLine(message);
}
// 实例化一个委托
MyDelegate h = DelegateMethod; 或 MyDelegate h=new MyDelegate (DelegateMethod);
// 调用委托对象(此时可以看作方法)
h ("Hello World");
针对以上实例化委托,也可以简写成如下:
Del h=delegate(DelegateMethod)
{
//方法体
}
它把委托对象的生成和方法写在一起,这就是所谓的匿名方法和匿名委托。
这看起来是不是特别晕啊,^_^!
至此,我们理解了委托是什么,但是我可以保证看了以下文字后就变得”不理解”了。
在C#中,当定义了一个委托,如MyDelegate,则C#编译器就会根据委托得定义语句自动生成一个从System.MulticastDelegate类继承的类MyDelegate。它有一个构造函数,代码示意如下:
public class MyDelegate: System.MulticastDelegate
{
public MyDelegate(object target,Int32 methodPtr);//构造函数
{
}
}
构造函数中有两个参数:前者target变量是调用方法的对象(在事件处理中,它就标识事件这个对象),如果委托对象要调用的是实例方法,那么target就是定义实例方法的类的实例。如果委托要调用的方法是静态方法,则target就为null。[这是很显然的^_^] 后者methodPtr变量是委托要调用的方法,这个值不能为null。这文字说明,委托对象如果指向的是静态方法,只要把静态方法名传入委托的构造方法就可以了。否则,必须把调用这个实例方法的对象引用传入target,否则就要使用[对象名.方法名()]的方式(如果委托指向的是当前类里面的实例方法,target可以用this传递,但方法是默认传递this引用的,所以这种情况下,也可以不指定target值)。我可以肯定的是很多C#编程的读物都没有把以上这个问题说清楚。(特别是会和委托声明里面的参数说明混乱)
定义定制事件
public class IOMonitor
{
public delegate void IODelegate(string s);
  public event IODelegate DataReceived;//非常注意:这里的DataReceived是一个引用变量,它标识一个事件,它指向的对象保存的是委托的引用。(MD,类似指针的指针)
}
DataReceived这个事件变量声明时就说明了它的是关联到IODelegate这个委托类型的对象的。(跟委托声明的时候的参数意义差不多)所以当生成IODelegate这个委托类型对象的时候,在它的构造函数里面就不用指定target的值了。
(插入日志用图)
最后,如果你之前没有任何有关委托的概念,而现在看了以上的解释,一点都不觉得含糊,那么我很佩服你,你是一个很聪明的人。有了事件和委托的概念就可以很好的理解Wondows的事件驱动模型了。
这是我对C#中事件的通俗看法,比较适合初学者(其实我也是初学者)对C#事件的理解,本人因为刚入门,在学习C#的事件原理时,发现很多书上写得很不好理解,不适合初学者,所以我想在这里谈谈我对它的看法,可能不是很准确,如果说得对的,请大家鼓鼓掌,不对的或是不规范的地方,还请高手帮忙更正一下,谢谢了。

在学C#之前,我看过《JAVA编程思想》,还有一些JAVA的入门级的书籍,其中对事件的讲解,总是用事件监听,事件适配器来举例,

所以我就一直认为,在C#中,RUNTIMING会一直监测每个控件的状态,如果有控件的状态发生改变和话,就会触发事件。

后来仔细看了一些例题之后,发现这个想法真的是很傻的。

其实,理解C#的事件原理,必须明白以下一点:

控件属性的改变,在它的类中,是由set来改变的,可以理解为由方法(method)来改变的,而不是简单的赋值。

举个例子来说明:
class shape
{
private int cvalue;
public shape()
{cvalue = 0;} 
public int colorvalue
{
set{cvalue = value;}
get{return cvalue;}
}
}

class MainApp
{
static void Main(string[] argvs)
{
shape trigon = new shape();
trigon.colorvalue = 3;
}
}

假设,当trigon的属性colorvalue发生改变时,会激发一个ColorChange事件,如果当colorvalue变化时,我们需要它向用户发送一个信息,例如:MessageBox.Show("The Color is Changed!"),那么,通常做法是给shape定义一个事件(怎么样定义这里就不讲了)ColorValueChange,先假设已定义,所以:
class MainApp
{
static void Main(string[] argvs)

shape trigon = new shape();
trigon.ColorChange += EventHandler(this.Shape_ColorValue);
trigon.colorvalue = 3;
}
private void Shape_ColorValueChange(object sender, System.EventArgs e)
{
MessageBox.Show("The Color is Changed!");

}
因此,当trigon的ColorValue被改变时,事件会被触发;上面的情况,和下面的代码,在结果上是等效的:
class shape
{
private int cvalue;
public shape()
{cvalue = 0;} 
public int colorvalue
{
set{cvalue = value; MessageBox.Show("The Color is Changed!");}
get{return cvalue;}
}
}

class MainApp
{
static void Main(string[] argvs)
{
shape trigon = new shape();
trigon.colorvalue = 3;
}
}
但是,一但我们这样定义一个类,如果shape类的使用者不仅仅是想给用户一个信息,他还想达到其它目的话,这个办法就行不通了,所以C#就有了事件委托这个东东。

我是这样理解事件委托的:委托可以接受一个方法的引用作为参数,然后执行这个方法。

所以,我们只要把MessageBox.Show("The Color is Changed!");换成事件委托就可以了,所以,shape类的使用者想要实现一个操作,他只要把他所要的操作定义成一个方法,再把这个方法通过委托,将其引用传给shape类的实例,让这个实例执行这个方法。

这种理解方法虽然不是很规范,但是,对理解C#的事件委托是很有帮助的,希望高手不要笑话。

下面让我们把shape类完整实现吧(现在就很好理解了):
using System;
namespace WinApp
{
//定义一个事件委托类型,注意不是事件
public delegate void ColorChangeEvent(object sender); 
public class shape
{
protected int cvalue;

//根据事件委托类型构造一个事件
public event ColorChangeEvent ColorChange;

public int colorvalue
{
set
{
cvalue = value;
ColorChange(this);//在colorvalue的值发生改变后,触发事件。
}
get
{
return cvalue;

}
public shape()
{
cvalue = 0 ;
}

}
}

下面是使用shape类的例子:
.
.
.
.
private shape trigon = new shape();

/*
通过委托,将trigon_ColorChange方法的引用传递给shape的实例,一旦实例中执行了ColorChange,
trigon_ColorChange方法就会被调用
*/
this.trigon.ColorChange += new WinApp.ColorChangeEvent(this.trigon_ColorChange);
.
.
.
private void button1_Click(object sender, System.EventArgs e)
{
this.trigon.colorvalue = 3;
}

private void trigon_ColorChange(object sender)
{
MessageBox.Show("The Color is Changed!");
}
.
.
.


什么是委托?

委托和事件这两个概念是完全配合的。委托仅仅是函数指针,那就是说,它能够引用函数,通过传递地址的机制完成。委托是一个类,当你对它实例化时,要提供一个引用函数,将其作为它构造函数的参数。

每一个委托都有自己的签名,例如:Delegate int SomeDelegate(string s, bool b);是一个委托申明,在这里,提及的签名,就是说SomeDelegate 这个委托 有 string 和 bool 类型的形参,返回一个int 类型。

上面提及的:当你对委托实例化时,要提供一个引用函数,将其作为它构造函数的参数。这里要注意了:被引用的这个函数必须和委托有相同的签名。

看下面的函数:

private int SomeFunction(string str, bool bln){...}

你可以把这个函数传给SomeDelegate的构造函数,因为他们有相似的签名(in other words,他们都有相同的形参类型和个数,并且返回相同的数据类型)。

SomeDelegate sd = new SomeDelegate(SomeFunction);

sd 引用了 SomeFunction,也就是说,SomeFunction已被sd所登记注册,如果你调用 sd,SomeFunction 这个函数也会被调用,记住:我所说 SomeFunction的含义,后面,我们会用到它。

现在,你应该知道如何使用委托了,让我们继续理解事件之旅……

事件的理解

我们知道,在C#中:

?按钮(Button)就是一个类,当我们单击它时,就触发一次click事件。

?时钟(Timer)也是一个类,每过一毫秒,就触发一次tick事件。

让我们通过一个例子来学习,假定有这样的情节:

现在有一个Counter的类,它有一个方法 CountTo(int countTo, int reachableNum),该方法表示:在指定的时间段内(0~~countTo),当到达指定的时间点reachableNum时,就触发一次NumberReached事件。

它还有一个事件:NumberReached,事件是委托类型的变量。意思是:如果给事件命名,用event关键字和要使用的委托类型申明它即可,如下所示:

public event NumberReachedEventHandler NumberReached;

在上面的申明中,NumberReachedEventHandle 仅是一个委托,更确切的表示应该是:NumberReachedDelegate。但是微软从不这样认为MouseDelegate或者PaintDelegate,,而是称谓:MouseEventHandler 或者 PaintEventHandler。所以NumberReachedEventHandler 比NumberReachedDelegate听起来更方便一些,OK?好了,让我们继续,现在你知道了,在我们声明事件之前,需要象下面这样的形式来定义委托:

public delegate void NumberReachedEventHandler(object sender, NumberReachedEventArgs e);

现在声明的委托 NumberReachedEventHandle,它有一个void 返回值,和object,NumberReachedEventArgs两个形参。就像我们在第一节中强调的那样,当实例化委托时,作为实参传入的函数也必须拥有和委托同样的签名。

在你的代码中,你是否用过PaintEventArgs 或者 MouseEventArgs来确定鼠标的移动位置?是否在触发Paint事件的对象中用过Graphics 属性?实际上,为用户提供数据的类都是继承于System.EventArgs类,就是我们常说的事件参数类,如果事件不提供参数,就不定义该类。在我们的例子中,我们通过下面的类提供预期的时间点。

public class NumberReachedEventArgs : EventArgs

{

private int _reached;

public NumberReachedEventArgs(int num)

{

this._reached = num;

}

public int ReachedNumber

{

get

{

return _reached;

}

}

}

好,有了前面的介绍,让我们到Counter类里面看看:

namespace Events

{

public delegate void NumberReachedEventHandler(object sender,

NumberReachedEventArgs e);

/// <summary>

/// Summary description for Counter.

/// </summary>

public class Counter

{

public event NumberReachedEventHandler NumberReached;

public Counter()

{

//

// TODO: Add constructor logic here

//

}

public void CountTo(int countTo, int reachableNum)

{

if(countTo < reachableNum)

throw new ArgumentException(

"reachableNum should be less than countTo");

for(int ctr=0;ctr<=countTo;ctr++)

{

if(ctr == reachableNum)

{

NumberReachedEventArgs e = new NumberReachedEventArgs(

reachableNum);

OnNumberReached(e);

return;//don't count any more

}

}

}

protected virtual void OnNumberReached(NumberReachedEventArgs e)

{

if(NumberReached != null)

{

NumberReached(this, e);//Raise the event

}

}

}

在Counter中,如果到达指定的时间点,就触发一次事件,有以下几个方面需要注意:

?通过调用NumberReached(它是NumberReachedEventHandler委托的实例)来完成一次触发事件。

NumberReached(this, e); 通过这种方式,可以调用所有的注册函数。

?通过 NumberReachedEventArgs e = new NumberReachedEventArgs(reachableNum); 为所有的注册函数提供事件数据。

?看了上面的代码,你可能要问了:为什么我们直接用 OnNumberReached(NumberReachedEventArgs e)方法来调用NumberReached(this,e),而不用下面的代码呢?

if(ctr == reachableNum)

{

NumberReachedEventArgs e = new NumberReachedEventArgs(reachableNum);

//OnNumberReached(e);

if(NumberReached != null)

{

NumberReached(this, e);//Raise the event

}

return;//don't count any more

}

这个问题问得很好,那就让我们再看一下OnNumberReached 签名:

protected virtual void OnNumberReached(NumberReachedEventArgs e)

①你也明白 关键字protected限定了 只有从该类继承的类才能调用该类中的所有方法。

②关键字 virtual 表明了 在继承类中可以重写该方法。

这两点非常有用,假设你在写一个从Counter继承而来的类,通过重写OnNumberReached 方法,你可以在事件触发之前,进行一次其他的工作。

protected override void OnNumberReached(NumberReachedEventArgs e)

{

//Do additional work

base.OnNumberReached(e);

}

注意:如果你没有调用base.OnNumberReached(e), 那么从不会触发这个事件!在你继承该类而想剔出它的一些其他事件时,使用该方式是非常有用的。

?还要注意到:委托 NumberReachedEventHandler 是在类定义的外部,命名空间内定义的,对所有类来说是可见的。

好,该我们来实际操作使用Counter类了。


在我们简单的应用程序中,我们有两个文本框,分别是:txtCountTo和txtReachable:

下面是btnRun的click事件:

private void btnRun_Click(object sender, System.EventArgs e)

{

if(txtCountTo.Text == "" || txtReachable.Text=="")

return;

oCounter.CountTo(Convert.ToInt32(txtCountTo.Text), Convert.ToInt32(txtReachable.Text));

}

private void oCounter_NumberReached(object sender, NumberReachedEventArgs e)

{

MessageBox.Show("Reached: " + e.ReachedNumber.ToString());

}

初始化事件处理的语法如下:

oCounter = new Counter(); 
oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached);

现在你明白了你刚才所做的一切,仅仅初始化 NumberReachedEventHandler 委托类型的对象(就像你实例化其他对象一样),注意到 oCounter_NumberReached 方法的签名与我前面提到的相似。

还要注意我们用的是+= 而不是=;这是因为委托是特殊的对象,它可以引用多个对象(在这里是指它可以引用多个函数)。For example 如果有另外一个和oCounter_NumberReached一样具有相同签名的函数oCounter_NumberReached2,这两个函数都可以被引用:

oCounter = new Counter();

oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached);

oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached2);

现在,触发一个事件后,上面两个函数被依次调用。

视情况而定,如果你想让oCounter_NumberReached2在NumberReached事件发生后不再被调用,可以简单地这样写:oCounter.NumberReached -= new NumberReachedEventHandler(oCounter_NumberReached2);

最后

让我们看一下完整的源代码,以供参考:


Form1.cs


using System; 
using System.Drawing; 
using System.Collections; 
using System.ComponentModel; 
using System.Windows.Forms; 
using System.Data; 

namespace Events 

/**//// <summary> 
/// Summary description for Form1. 
/// </summary> 
public class Form1 : System.Windows.Forms.Form 

Counter oCounter = null; 

private System.Windows.Forms.Button cmdRun; 
private System.Windows.Forms.TextBox txtReachable; 
private System.Windows.Forms.TextBox txtCountTo; 
private System.Windows.Forms.Label label1; 
private System.Windows.Forms.Label label2; 
private System.Windows.Forms.Button btnRemoveDelegate; 
/**//// <summary> 
/// Required designer variable. 
/// </summary> 
private System.ComponentModel.Container components = null; 

public Form1() 

// 
// Required for Windows Form Designer support 
// 
InitializeComponent(); 

// 
// TODO: Add any constructor code after InitializeComponent call 
// 
oCounter = new Counter(); 
oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached); 
oCounter.NumberReached += new NumberReachedEventHandler(oCounter_NumberReached2); 


/**//// <summary> 
/// Clean up any resources being used. 
/// </summary> 
protected override void Dispose( bool disposing ) 

if( disposing ) 

if (components != null) 

components.Dispose(); 


base.Dispose( disposing ); 


Windows Form Designer generated code#region Windows Form Designer generated code 
/**//// <summary> 
/// Required method for Designer support - do not modify 
/// the contents of this method with the code editor. 
/// </summary> 
private void InitializeComponent() 

this.cmdRun = new System.Windows.Forms.Button(); 
this.txtReachable = new System.Windows.Forms.TextBox(); 
this.txtCountTo = new System.Windows.Forms.TextBox(); 
this.label1 = new System.Windows.Forms.Label(); 
this.label2 = new System.Windows.Forms.Label(); 
this.btnRemoveDelegate = new System.Windows.Forms.Button(); 
this.SuspendLayout(); 
// 
// cmdRun 
// 
this.cmdRun.Location = new System.Drawing.Point(16, 72); 
this.cmdRun.Name = "cmdRun"; 
this.cmdRun.Size = new System.Drawing.Size(48, 23); 
this.cmdRun.TabIndex = 2; 
this.cmdRun.Text = "Run"; 
this.cmdRun.Click += new System.EventHandler(this.cmdRun_Click); 
// 
// txtReachable 
// 
this.txtReachable.Location = new System.Drawing.Point(144, 40); 
this.txtReachable.Name = "txtReachable"; 
this.txtReachable.Size = new System.Drawing.Size(56, 20); 
this.txtReachable.TabIndex = 1; 
this.txtReachable.Text = ""; 
// 
// txtCountTo 
// 
this.txtCountTo.Location = new System.Drawing.Point(144, 16); 
this.txtCountTo.Name = "txtCountTo"; 
this.txtCountTo.Size = new System.Drawing.Size(56, 20); 
this.txtCountTo.TabIndex = 0; 
this.txtCountTo.Text = ""; 
// 
// label1 
// 
this.label1.AutoSize = true; 
this.label1.Location = new System.Drawing.Point(16, 16); 
this.label1.Name = "label1"; 
this.label1.Size = new System.Drawing.Size(51, 13); 
this.label1.TabIndex = 3; 
this.label1.Text = "Count To"; 
// 
// label2 
// 
this.label2.AutoSize = true; 
this.label2.Location = new System.Drawing.Point(16, 40); 
this.label2.Name = "label2"; 
this.label2.Size = new System.Drawing.Size(99, 13); 
this.label2.TabIndex = 4; 
this.label2.Text = "Reach this number"; 
// 
// btnRemoveDelegate 
// 
this.btnRemoveDelegate.Location = new System.Drawing.Point(16, 104); 
this.btnRemoveDelegate.Name = "btnRemoveDelegate"; 
this.btnRemoveDelegate.Size = new System.Drawing.Size(168, 23); 
this.btnRemoveDelegate.TabIndex = 5; 
this.btnRemoveDelegate.Text = "Remove second handler"; 
this.btnRemoveDelegate.Click += new System.EventHandler(this.btnRemoveDelegate_Click); 
// 
// Form1 
// 
this.AutoScaleBaseSize = new System.Drawing.Size(5, 13); 
this.ClientSize = new System.Drawing.Size(224, 134); 
this.Controls.AddRange(new System.Windows.Forms.Control[] { 
this.btnRemoveDelegate, 
this.label2, 
this.label1, 
this.txtCountTo, 
this.txtReachable, 
this.cmdRun}); 
this.Name = "Form1"; 
this.Text = "Events"; 
this.ResumeLayout(false); 


#endregion 

/**//// <summary> 
/// The main entry point for the application. 
/// </summary> 
[STAThread] 
static void Main() 

Application.Run(new Form1()); 


private void btnRun_Click(object sender, System.EventArgs e) 

if(txtCountTo.Text == "" || txtReachable.Text=="") 
return; 
oCounter.CountTo(Convert.ToInt32(txtCountTo.Text), Convert.ToInt32(txtReachable.Text)); 


private void oCounter_NumberReached(object sender, NumberReachedEventArgs e) 

MessageBox.Show("Reached: " + e.ReachedNumber.ToString()); 

private void oCounter_NumberReached2(object sender, NumberReachedEventArgs e) 

MessageBox.Show("Reached2: " + e.ReachedNumber.ToString()); 


private void btnRemoveDelegate_Click(object sender, System.EventArgs e) 

oCounter.NumberReached -= new NumberReachedEventHandler(oCounter_NumberReached2); 
oCounter.CountTo(Convert.ToInt32(txtCountTo.Text), Convert.ToInt32(txtReachable.Text)); 




Counter.cs


using System; 

namespace Events 

public delegate void NumberReachedEventHandler(object sender, NumberReachedEventArgs e); 

/**//// <summary> 
/// Summary description for Counter. 
/// </summary> 
public class Counter 

public event NumberReachedEventHandler NumberReached; 

public Counter() 

// 
// TODO: Add constructor logic here 
// 

public void CountTo(int countTo, int reachableNum) 

if(countTo < reachableNum) 
throw new ArgumentException("reachableNum should be less than countTo"); 
for(int ctr=0;ctr<=countTo;ctr++) 

if(ctr == reachableNum) 

NumberReachedEventArgs e = new NumberReachedEventArgs(reachableNum); 
OnNumberReached(e); 
return;//don't count any more 




protected virtual void OnNumberReached(NumberReachedEventArgs e) 

if(NumberReached!=null) 

NumberReached(this, e); 




public class NumberReachedEventArgs : EventArgs 

private int _reached; 
public NumberReachedEventArgs(int num) 

this._reached = num; 

public int ReachedNumber 

get 

return _reached; 



}

阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页