C#委托,事件理解入门(转载)

C#委托,事件理解入门 (译稿)

目录

l 导论

l 什么是委托

l 事件的理解

l 事件 关键字

l 最后

导论

在学习C#中的委托和事件过程中，我读了许多文章来理解他们二者究竟是怎么一回事，以及如何使用他们，现在我将整个的理解过程陈述以下，我学到的每一方面，恐怕也是你们需要掌握的：-）。

什么是委托？

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

每一个委托都有自己的签名，例如：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#中：

l 按钮（Button）就是一个类，当我们单击它时，就触发一次click事件。

l 时钟（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中，如果到达指定的时间点，就触发一次事件，有以下几个方面需要注意：

l 通过调用NumberReached（它是NumberReachedEventHandler委托的实例）来完成一次触发事件。

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

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

l 看了上面的代码，你可能要问了：为什么我们直接用 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), 那么从不会触发这个事件！在你继承该类而想剔出它的一些其他事件时，使用该方式是非常有用的。

l 还要注意到：委托 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

/// <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;

}

}

}

}

好多人一直在问:什么时候该用委托,为什么要用委托,委托有什么好处....

看完下面的文章你将茅塞顿开..(看不懂的直接TDDTDS)

概念虽然我不喜欢讲太多

我们直接先来YY 个场景:我很喜欢打游戏,但运气不好每次打游戏都会被主管看到,朱老板不喜欢他的员工在上班的时

间打游戏,所以朱老板就跟主管说:以后员工在打游戏,你就扣他20块钱.

这其实就是一个委托,朱老板委托主管一旦发现员工打游戏,就做一件事情.

程序该怎么写呢?

至少有2个类吧,主管与员工,主管有个方法扣钱,员工有个方法玩游戏,那么开始动工了

员工类:

public class Employee

{

//员工的薪水

private int money;

//该员工的主管

private Manager Manager;

public Employee(Manager manager)

{

// 通过构造函数，初始化员工的主管与薪水。

Manager = manager;

money = 8000;

}

public int Money

{

get { return money; }

set { money = value; }

}

public void PlayGame()

{

System.Diagnostics.Debug.WriteLine("员工:开始玩游戏了..");

System.Diagnostics.Debug.WriteLine("员工:CS真好玩，哈哈哈！ 我玩...");

Manager.RemoveMoney(this);

}

}

主管类:

public class Manager

{

public Manager()

{

}

//扣薪水

public void RemoveMoney(Employee employee)

{

System.Diagnostics.Debug.WriteLine("主管：上班时间胆敢玩游戏");

System.Diagnostics.Debug.WriteLine("主管：看看你小子有多少薪水:" + employee.Money);

System.Diagnostics.Debug.WriteLine("主管：我开始扣薪水...");

employee.Money -= 20;

System.Diagnostics.Debug.WriteLine("主管：扣好了.");

System.Diagnostics.Debug.WriteLine("主管：看看你小子薪水剩余：" + employee.Money);

}

}

MIan方法大概这么写就行了:

public static void Main(string[] args)

{

// 生成主管类的对象实例 king

Manager king = new Manager();

// 生成员工类类的对象实例 wind

Employee wind = new Employee(king);

// 员工开始玩游戏

wind.PlayGame();

}

运行,果然结果是对的,看来做为程序员我还是比较低调的..写出来结果很正常,也不沾沾自喜..

员工:开始玩游戏了..

员工:CS真好玩，哈哈哈！ 我玩...

主管：上班时间胆敢玩游戏

主管：看看你小子有多少薪水:8000

主管：我开始扣薪水...

主管：扣好了.

主管：看看你小子薪水剩余：7980

下面我们简单的分析下这个程序:

1:在创建主管类之后才能创建员工类,耦合性太高,也就是说你要创建个员工,必须要先创建个主管..

2:如果场景发生以下变化,我要让经理代替主管,我们不得不修改员工类,并增加经理类.

这样看来这段程序设计的并不好,我们不妨来考虑下事件(特殊的委托)来实现

必须要定义一个委托,就是让主管监视员工,然后员工类里要有个事件(员工也是激发该事件的对象),主管执行事件

public delegate void Play(Object Sender, System.EventArgs e);

public class Employee

{

public int money = 2200;//懒得写属性了..

public event Play play;

public Employee()

{

}

public void PlayGame()

{

System.EventArgs e = new EventArgs();

OnPlayGame(this, e);

}

void OnPlayGame(object Sender, EventArgs e)

{

if (play != null)

{

play(Sender, e);

}

}

}

主管类就要实现一个方法,这个方法与委托的返回直一样,参数一样就行了,给委托来调用的.:

public class Manager

{

public Manager()

{

}

public void RemoveMoney(Object Sender, System.EventArgs e)

{

Employee emp = Sender as Employee;

emp.money -= 20;

System.Diagnostics.Debug.WriteLine(emp.money);

}

}

那么调用就变的简单了

Manager xiaotao = new Manager();

// 生成员工类的对象实例 shulin

Employee shulin = new Employee();

// 设下委托，指定监视

shulin.play += new Play(xiaotao.RemoveMoney);

// 员工开始玩游戏,玩一次扣一次

e.PlayGame();

e.PlayGame();

输出:

2180

2160

总结：

当然，不使用委托和事件我们仍然可以设计出解耦的类，然而却会增加很多的类、接口以及关联等等，增加了代码量和程序的逻辑复杂性，而在.net里利用委托和事件我们只需少的多的代码来实现。