C# 委托和事件
时间：2010-09-09 来源：wl98766789
在讲委托，事件之前，我想问大家一个非常简单的问题，也许在我们日常的编程中基本上每天都会遇到，但是却往往不去了解的地方，请以下代码：
protected void Page_Load(object sender, EventArgs e)
{
}
protected void btnSearch_Click(object sender, ImageClickEventArgs e)
{
}
protected void grdBill_RowDataBound(object sender, GridViewRowEventArgs e)
{
}
protected void grdBill_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
}
看完之后大家是不是很熟悉，是不是我们每天都遇到过的，但是大家有没有想过所有方法中的两个参数（sender,e），到底是什么意思，有的人可能会说，这些
都是VS编译环境自动生成的，搞的这么清楚干什么，能用就行了呗，不就是个窗体加载事件、点击按钮事件嘛，第二种人可能马上会去百度，谷歌一下
会马上得出查询结果：
第一個,sender,也就是引起事件的那個對象
第二個,e,包含了事件的信息
现在来看看事件驱动程序的组成，主要是有事件、对象和事件处理程序三个要素。对象就是完成任务的主体，比如你说的Button1；事件么，就是对象要执行的任务，比如单击，就是click事件；那么事件处理程序就是Button1_Click这段程序了。sender as object，就一语道破它的来源与用途。object是支持 .NET 框架类层次结构中的所有类，并为派生类提供低级别服务。这是 .NET 框架中所有类的最终超类；它是类型层次结构的根。一般来说，sender在形参中表示引发事件的源头，就是我刚才所说的三要素中的‘对象’。如果在控件引发的事件中写代码的话，一般都不需要再重新指派，因为它已经默认为是该控件了。当自己写代码来调用某事件程序时，就要注明sender是何物了。再说e，表示的是事件数据，就是一个事件激发所需要的状态信息。在事件引发时不向事件处理程序传递状态信息的事件会将e设为Eventargs。如果事件处理程序需要状态信息，则应用程序必须从此类派生一个类来保存数据。比如Mousedown事件，系统需要判断mouse的位置、判断是左中右哪个键点击了、判断点击了几下等等，因此该e就必需是System.Windows.Forms.MouseEventArgs类的实例。
首先，我们还是先说说委托吧，从字面上理解，只要是中国人应该都知道这个意思，除非委托2个中文字不认识，举个例子，小明委托小张去买车票。
但是在我们的程序世界里，也是这么的简单吗？当然，什么是OO，OO就是现实世界的抽象，所有现实世界的事物，在OO里都能得到很好的诠释，不好意思，扯远了......
那我们就单刀直入吧，如果同学们不嫌烦的话，可以看一下，网上中文，英文的那个GreetingPeople例子。
首先是C#语法
public delegate void BugTicketEventHandler();
delegate 是关键词，【注：EventHandler是一个声明委托的微软C#的命名标准，我的习惯是标准就要第一时间说，也就这个命名习惯要第一时间养成】
完了，这就是委托，就这么简单，看看和我们一般的方法有什么区别呢？
public void BuyTicket()
{
方法体
}
区别知道了吧，在现实生活中，委托只是个命令，做事情是别人，而在程序世界里委托只是存储了各个方法的地址，而他自己也是什么也不做的。
那我们就把刚才那个，小明委托小张去买车票的现实生活场景，怎么在程序世界里体现呢？
//小张类
public class MrZhang
{
//其实买车票的悲情人物是小张
public static void BuyTicket()
{
Console.WriteLine("NND,每次都让我去买票，鸡人呀！");
}
}
//小明类
class MrMing
{
//声明一个委托，其实就是个“命令”
public delegate void BugTicketEventHandler();
public static void Main(string[] args)
{
//这里就是具体阐述这个命令是干什么的，本例是MrZhang.BuyTicket“小张买车票”
BugTicketEventHandler myDelegate = new BugTicketEventHandler(MrZhang.BuyTicket);
//这时候委托被附上了具体的方法
myDelegate();
Console.ReadKey();
}
}
BugTicketEventHandler myDelegate = new BugTicketEventHandler(MrZhang.BuyTicket); 这是委托的声明方法， BugTicketEventHandler(委托的方法);
委托的方法必须要加上，因为委托的构造函数是不为空的。
注：委托的参数和返回类型，都要和你要具体委托的方法要一致。
public delegate void BugTicketEventHandler();
public static void BuyTicket()
{
Console.WriteLine("NND,每次都让我去买票，鸡人呀！");
}
同学们，看到这里可以先消化消化，休息一下，我们简单的讲一下委托链的概念：其实委托链也是相当的简单，在现实生活中，小明叫小张买完车票之后，可能接着又让他带张电影票， 而我们程序世界里的表述为：
//小张类
public class MrZhang
{
//其实买车票的悲情人物是小张
public static void BuyTicket()
{
Console.WriteLine("NND,每次都让我去买票，鸡人呀！");
}
public static void BuyMovieTicket()
{
Console.WriteLine("我去，自己泡妞，还要让我带电影票！");
}
}
//小明类
class MrMing
{
//声明一个委托，其实就是个“命令”
public delegate void BugTicketEventHandler();
public static void Main(string[] args)
{
//这里就是具体阐述这个命令是干什么的，本例是MrZhang.BuyTicket“小张买车票”
BugTicketEventHandler myDelegate = new BugTicketEventHandler(MrZhang.BuyTicket);
myDelegate += MrZhang.BuyMovieTicket;
//这时候委托被附上了具体的方法
myDelegate();
Console.ReadKey();
}
}
其实，我们只是在程序中加了 myDelegate += MrZhang.BuyMovieTicket;这时这个委托就相当于要做2件事情，先是买车票，再是买电影票拉！
什么是事件？EVENT？点击事件？加载事件？一连串的模糊的概念冲击着我们弱小的脑袋
那我们首先来看一下比较正统的感念吧：
事件是类在发生其关注的事情时用来提供通知的一种方式。
事件的发生一般都牵扯2个角色
事件发行者（Publisher）:一个事件的发行者，也称作是发送者（sender），其实就是个对象，这个对象会自行维护本身的状态信息，当本身状态信息变动时，便触发一个事件，并通知说有的事件订阅者。
事件订阅者（Subscriber）:对事件感兴趣的对象，也称为Receiver，可以注册感兴趣的事件，在事件发行者触发一个事件后，会自动执行这段代码。
为了更好的让大家理解上面的概念，我先什么都不讲，我们先来看一段简单的代码：
public class Publisher
{
//声明一个出版的委托
public delegate void PublishEventHander();
//在委托的机制下我们建立以个出版事件
public event PublishEventHander OnPublish;
//事件必须要在方法里去触发，出版社发布新书方法
public void issue()
{
//如果有人注册了这个事件，也就是这个事件不是空
if (OnPublish != null)
{
Console.WriteLine("最新一期的《火影忍者》今天出版哦！");
OnPublish();
}
}
}
//Subscriber 订阅者，无赖小明
public class MrMing
{
//对事件感兴趣的事情，这里指对出版社的书感兴趣
public static void Receive()
{
Console.WriteLine("嘎嘎，我已经收到最新一期的《火影忍者》啦！！");
}
}
//Subscriber 订阅者，悲情人物小张
public class MrZhang
{
//对事件感兴趣的事情
public static void Receive()
{
Console.WriteLine("幼稚，这么大了，还看《火影忍者》，SB小明！");
}
}
class Story
{
public static void Main(string[] args)
{
//实例化一个出版社
Publisher publisher = new Publisher();
//给这个出火影忍者的事件注册感兴趣的订阅者，此例中是小明
publisher.OnPublish += new Publisher.PublishEventHander(MrMing.Receive);
//另一种事件注册方式
//publisher.OnPublish += MrMing.Receive;
//发布者在这里触发出版火影忍者的事件
publisher.issue();
Console.ReadKey();
}
}
编译结果如下：
如果童靴们，从上到下仔细看一边的话，我想应该知道什么是发布者，什么是订阅者了吧，那至于事件呢
我们先看这句
publisher.OnPublish += new Publisher.PublishEventHander(MrMing.Receive);
这就是小明向出版社订阅他喜欢看的火影忍者，小张没有订阅所以小张没有收到书，
我们再仔细看看这个赋值语句，是不是似曾相识过呢？是的就是我们在上一讲，在讲委托声明的时候，简直就是一个眸子里刻出来的嘛
委托赋值：
BugTicketEventHandler myDelegate = new BugTicketEventHandler(MrZhang.BuyTicket);
所以，大家不要对事件有什么好怕的，其实事件的本质就是一个委托链，
我们看一下事件的声明：
//声明一个出版的委托
public delegate void PublishEventHander();
//在委托的机制下我们建立以个出版事件
public event PublishEventHander OnPublish;
在我们使用事件的时候，必须要声明对应的委托，而触发事件，其实就是在使用委托链。
今天我接着上面的3篇文章来讲一下，为什么我们在日常的编程活动中遇到这么多sender,EventArgs e 参数：
protected void Page_Load(object sender, EventArgs e)
{
}
protected void btnSearch_Click(object sender, ImageClickEventArgs e)
{
}
protected void grdBill_RowDataBound(object sender, GridViewRowEventArgs e)
{
}
那他们到底表示什么呢？
在回答上面的问题之前，我们先搞懂 .Net Framework的编码规范：
一、委托类型的名称都应该以EventHandler结束。
二、委托的原型定义：有一个void返回值，并接受两个输入参数：一个Object 类型，一个 EventArgs类型(或继承自EventArgs)。
三、事件的命名为 委托去掉 EventHandler之后剩余的部分。
四、继承自EventArgs的类型应该以EventArgs结尾。
这就是微软编码的规范，当然这不仅仅是规则，而是在这种规则下使程序有更大的灵活性，那我们就继续重构第三讲的例子，让他符合微软的规范。
//所有订阅者【Subscriber】感兴趣的对象，也就是e,都要继承微软的EventArgs
//本例中订阅者【也称观察者】MrMing，MrZhang他们感兴趣的e对象，就是杂志【magazine】
public class PubEventArgs : EventArgs
{
public readonly string magazineName;
public PubEventArgs()
{
}
public PubEventArgs (string magazineName)
{
this.magazineName = magazineName;
}
}
//发布者（Publiser)
public class Publisher
{
//声明一个出版的委托
//这里多了一个参数sender,它所代表的就是Subject，也就是监视对象，本例中就是Publisher
public delegate void PublishEventHander(object sender ,PubEventArgs e);
//在委托的机制下我们建立以个出版事件
public event PublishEventHander Publish;
//声明一个可重写的OnPublish的保护函数
protected virtual void OnPublish(PubEventArgs e)
{
if (Publish != null)
{
//Sender = this，也就是Publisher
this.Publish(this, e);
}
}
//事件必须要在方法里去触发
public void issue(string magazineName)
{
OnPublish(new PubEventArgs(magazineName));
}
}
//Subscriber 订阅者
public class MrMing
{
//对事件感兴趣的事情
public static void Receive(object sender,PubEventArgs e)
{
Console.WriteLine("嘎嘎，我已经收到最新一期的《"+e.magazineName+"》啦！！");
}
}
public class MrZhang
{
//对事件感兴趣的事情
public static void Receive(object sender, PubEventArgs e)
{
Console.WriteLine("幼稚，这么大了，还看《火影忍者》，SB小明！");
Console.WriteLine("这个我定的《"+e.magazineName+"》，哇哈哈！");
}
}
class Story
{
public static void Main(string[] args)
{
//实例化一个出版社
Publisher publisher = new Publisher();
Console.Write("请输入要发行的杂志：");
string name = Console.ReadLine();
if (name == "火影忍者")
{
//给这个出火影忍者的事件注册感兴趣的订阅者，此例中是小明
publisher.Publish += new Publisher.PublishEventHander(MrMing.Receive);
//发布者在这里触发出版火影忍者的事件
publisher.issue("火影忍者");
}
else
{
//给这个出火影忍者的事件注册感兴趣的订阅者，此例中是小明[另一种事件注册方式]
publisher.Publish += MrZhang.Receive;
publisher.issue("环球日报");
}
Console.ReadKey();
}
}
输入火影忍者后，触发小明订阅的事件
显示:
通过例子我再做一次说明，其实我们不用把Sender,e想的过于可怕
一、委托声明原型中的Object类型的参数代表了Subject，也就是监视对象，在本例中是 Publisher(出版社)。。
二、EventArgs 对象包含了Observer所感兴趣的数据，在本例中是杂志。
好了，我们接着讲我们的委托与事件，其实如果大家对设计模式精通的话，其实他们关联的是观察者（Observer）模式，这里我就不再描述什么是观察者模式了，只是简单讲一下他们的关联：
在C#的event中，委托充当了抽象的Observer接口，而提供事件的对象充当了目标对象。委托是比抽象Observer接口更为松耦合的设计。
如果看不懂的话也没关系，当大家OO达到一定程度了，自然而然就会明白。
最后我们来看一个我们日常最最常用的观察者模式：
场景：当我们用信用卡刷完钱的时候，我们就会接收到手机短信，或者是电子邮件，其实这就是Observer pattern
//---本例场景为当用户从银行账号里取出钱后，马上通知电子邮件和发手机短信---
//本例中的订阅者，也就是观察者是电子邮件与手机
//发布者，也就是被监视对象是银行账号
//Obverser电子邮件，手机关心的对象e ,分别是邮件地址、手机号码、取款金额
public class UserEventArgs : EventArgs
{
public readonly string emailAddress;
public readonly string mobilePhone;
public readonly string amount;
public UserEventArgs(string emailAddress, string mobilePhone,string amount)
{
this.emailAddress = emailAddress;
this.mobilePhone = mobilePhone;
this.amount = amount;
}
}
//发布者，也就是被监视的对象-银行账号
class BankAccount
{
//声明一个处理银行交易的委托
public delegate void ProcessTranEventHandler(object sender, UserEventArgs e);
//声明一个事件
public event ProcessTranEventHandler ProcessTran;
protected virtual void OnProcessTran(UserEventArgs e)
{
if (ProcessTran != null)
{
ProcessTran(this, e);
}
}
public void Prcess(UserEventArgs e)
{
OnProcessTran(e);
}
}
//观察者Email
class Email
{
public static void SendEmail(object sender, UserEventArgs e)
{
Console.WriteLine("向用户邮箱" + e.emailAddress + "发送邮件:您在"+System.DateTime.Now.ToString()+"取款金额为"+e.amount);
}
}
//观察者手机
class Mobile
{
public static void SendNotification(object sender, UserEventArgs e)
{
Console.WriteLine("向用户手机" + e.mobilePhone + "发送短信:您在" + System.DateTime.Now.ToString() + "取款金额为" + e.amount);
}
}
//订阅系统，实现银行系统订阅几个Observer，实现与客户端的松耦合
class SubscribSystem
{
public SubscribSystem()
{
}
public SubscribSystem(BankAccount bankAccount, UserEventArgs e)
{
//现在我们在银行账户订阅2个，分别是电子邮件和手机短信
bankAccount.ProcessTran += new BankAccount.ProcessTranEventHandler(Email.SendEmail);
bankAccount.ProcessTran += new BankAccount.ProcessTranEventHandler(Mobile.SendNotification);
bankAccount.Prcess(e);
}
}
class Client
{
public static void Main(string[] args)
{
Console.Write("请输入您要取款的金额：");
string amount = Console.ReadLine();
Console.WriteLine("交易成功，请取磁卡。");
//初始化e
UserEventArgs user = new UserEventArgs("[email protected]", "18868789776",amount);
//初始化订阅系统
SubscribSystem subject = new SubscribSystem(new BankAccount(), user);
Console.ReadKey();
}
}
控制台
网上还有个热水器烧水的OBSERVER PATTERN 也是蛮经典的，大家可以看看。
下面我们要讲讲，在我们的日常的MES系统开发中，到底在什么场景用到委托事件，毕竟我们学了这样的技术，我们必须要用起来，这才有价值嘛！
在日常的MES系统编程中到底怎样使用这样的利器，其实我们每天都在使用事件，一个窗体，一个按钮都包含这事件，只是很少用到自己写的委托和事件，说白了不知道如何下手，也不知道在什么样的场景下应用。
用到事件的地方有很多，这次讲解就MES系统开发中我们经常应用的场景。
一、通用控件场景
通用控件有很多，这里举最常用的万能通用分页控件
【注：】本分页控件，只是为了讲解使用，并非真分页控件，还是基于.net控件的分页
我们先来看场景
我们所看到的这个分页控件就是这次讲解的主角，在日常的编程中，像这样功能我们用的做多，所以我们必须要把它抽象出来，不能每个页面都写分页逻辑吧。那我们想想到底怎样去实现这样的功能呢？怎样才能让页面知道我们按了控件的哪个按钮呢？这时候让我们联想一想委托与事件，一定要聚精会神，叮咚！有了，我们可以把这个控件想象成一个发布者，而各个页面就想象成订阅者，或者是观察者，当页面订阅了分页控件的事件后，自然就会相应了嘛？
有了思路，我们就开始行动吧！
第一步，我们编写发布者代码，也就是这个控件代码
public class PageChangeEventArgs : EventArgs
{
private string action = string.Empty;
public string Action
{
get
{
return this.action;
}
set
{
this.action = value;
}
}
public PageChangeEventArgs()
{
}
public PageChangeEventArgs(String paramAction)
{
this.Action = paramAction;
}
}
//发布者代码 也就是控件代码
public partial class UIPageControlsNavigator : System.Web.UI.UserControl
{
//这里我们声明一个页面改变的委托[注：命名一定要规范]
public delegate void PageChangeEventHandler(object sender, PageChangeEventArgs e);
//这里我们声明一个事件
public event PageChangeEventHandler PageChange;
//然后一个保护类型的OnPageChange方法
protected virtual void OnPageChange(PageChangeEventArgs e)
{
if (PageChange != null)
{
PageChange(this, e);
}
}
//这里就是上一讲中，具体的触发函数,这里变成了一个按钮触发事件
protected void lbtnFirst_Click(object sender, EventArgs e)
{
//这时候，订阅者关心的对象e，也就是触发的是“首页”这个按钮
OnPageChange(new PageChangeEventArgs("First"));
}
protected void lbtnPrevious_Click(object sender, EventArgs e)
{
//这时候，订阅者关心的对象e，也就是触发的是“下页”这个按钮
OnPageChange(new PageChangeEventArgs("Previous"));
}
protected void lbtnLast_Click(object sender, EventArgs e)
{
OnPageChange(new PageChangeEventArgs("Last"));
}
protected void lbtnNext_Click(object sender, EventArgs e)
{
OnPageChange(new PageChangeEventArgs("Next"));
}
protected void btnSearch_Click(object sender, EventArgs e)
{
if (IsNumber(txtSearchPageCount.Text))
{
OnPageChange(new PageChangeEventArgs("Search"));
}
}
protected void cmbPerPage_SelectedIndexChanged(object sender, EventArgs e)
{
OnPageChange(new PageChangeEventArgs("PageSizeChanged"));
}
....
#region public void BindData(GridView myGridView, IList businessObjects, PageChangeEventArgs e)
/// <summary>
/// 具体控件分页功能实现
/// </summary>
/// <param name="myGridView">当前Grid控件</param>
/// <param name="businessObjects">数据源</param>
/// <param name="e">事件对象</param>
public void BindData(GridView myGridView, IList businessObjects, PageChangeEventArgs e)
{
// 计算页面数
if (businessObjects == null)
{
this.RowCount = 0;
}
else
{
this.RowCount = businessObjects.Count;
}
double pageCount = (double)RowCount / this.PageSize;
this.PageCount = (int)Math.Ceiling(pageCount);
myGridView.DataSource = businessObjects;
myGridView.PageSize = this.PageSize;
switch (e.Action)
{
case "PageLoad":
if (CurrentPage > 0)
{
myGridView.PageIndex = CurrentPage - 1;
}
break;
case "First":
myGridView.PageIndex = 0;
myGridView.EditIndex = -1;
break;
case "Previous":
myGridView.PageIndex--;
myGridView.EditIndex = -1;
break;
case "Next":
myGridView.PageIndex++;
myGridView.EditIndex = -1;
break;
case "Last":
myGridView.PageIndex = this.PageCount - 1;
myGridView.EditIndex = -1;
break;
case "PageSizeChanged":
myGridView.PageIndex = 0;
myGridView.EditIndex = -1;
break;
case "Search":
myGridView.PageIndex = int.Parse(txtSearchPageCount.Text) - 1;
break;
case "Refresh":
break;
default:
myGridView.PageIndex = 0;
break;
}
// 页数不够了，进行调整
if (myGridView.PageIndex >= this.PageCount)
{
myGridView.PageIndex = this.PageCount == 0 ? 0 : this.PageCount - 1;
}
myGridView.DataBind();
// 获取按钮的状态
this.GetButtonState(myGridView);
}
#endregion
}
当然控件代码还不值这些，我这里就列举出我们委托事件需要的代码：
//角色管理页面代码类
public partial class RoleManage : BasePage
{
protected void Page_Load(object sender, EventArgs e)
{
//在当前页面订阅控件的点击事件
this.myNavigator.PageChange += new PageChangeEventHandler(this.myNavigator_PageChange);
if (!Page.IsPostBack)
{
}
}
//具体的点击触发函数功能，这里就是控件的分页
private void myNavigator_PageChange(object sender, PageChangeEventArgs e)
{
this.GetAllRoles(e);
}
private void GetAllRoles(PageChangeEventArgs e)
{
try
{
//角色数据源
roles = roleService.GetAllRoles();
//调用控件的分页功能函数，这个封装在分页控件里可以，封装在通用的类库里也行
this.myNavigator.BindData(this.grdRole, roles, e);
}
catch (Exception myException)
{
return;
}
}
}
其实原理很简单，当控件上按下下页或者其它按钮的时候，这时候因为角色管理页面已经订阅了这个事件，所以它会执行具体委托的那个实体函数，就这么简单
大家了看了可能会头大，那就自己动手试着做一下，只有做了才能真正的体会到里面的奥妙，其实和我上一讲内容很相识，只是稍微有一点点的变化而已。
接下来，我们具体来看场景：
这是一个工作流审批用户控件，做MES系统的其实经常会和这个打交道，然而我们把这个逻辑封装成一个控件，那我们在今后维护上将会减轻很多工作量
这里我只介绍这控件技术上我们用到的委托和事件的代码
public partial class ApprovalResults : System.Web.UI.UserControl
{
//EventHandler是微软默认的委托，在本例中我们直接就用EventHandler来表示委托，当然它的参数是Sender,e
public event EventHandler Preview;
public event EventHandler Submit;
public event EventHandler FMOK;
public event EventHandler FMProgress;
public event EventHandler FMSave;
...
//提交按钮事件
protected void btnSubmit_Click(object sender, EventArgs e)
{
try
{
//触发我们定义的事件
Submit(sender, e);
}
catch (Exception ex)
{
...
}
}
...
}
然后我们到订阅这个事件的页面上看一下代码
public partial class Preview : BasePage
{
protected void Page_Load(object sender, EventArgs e)
{
...
//在次页面中订阅审批控件的提交按钮事件
ApprovalResults1.Submit += new EventHandler(ApprovalResults1_Submit);
}
//具体的提交事件功能函数
public void ApprovalResults1_Submit(object sender, EventArgs e)
{
try
{
}
catch (Exception ex)
{
}
finally
{
}
}
}
这样我想大家都理解了，当审批控件点击提交按钮，其实访问的就是订阅者页面的功能函数。
其实委托事件应用的场景还有很多，它就是观察者模式的提炼。
相关阅读 更多 +
