CSDN博客

img ddarkelf

委托和事件

发表于2004/9/15 15:53:00  2881人阅读

分类: c#

C#代表元及事件触发


代表元是C#中比较复杂的概念,C#中的代表元和C/C++中的函数指针非常相似使用代表元可以把代表元内部方法的引用封装起来然后通过它使用代表元引用的方法。
它有一个特性就是不需要知道被引用的方法属于那一个类对象只要函数的参数个数与返回类型与代表元对象一致。这样说可能比较抽象我下面举几个简单的例子希望能给广大初学者一些基本的认识

//定义一个返回值为string的无参数的代表元注意这个代表元只能引用对象中返回值为string的无参数方法
delegate  string  MyDelegate();
public  class  MyClass
{
public  string  SayHello()
{
return  "Hello  the  world!";
}

}
public  class  TestMyClass
{
public  static  void  Main(string[]  args)
{
MyClass  myClass1=new  MyClass();
MyDelegate  myDelegate1=new  MyDelegate(myClass1.SayHello);
//下面就使用myDelegate1代替对象myClass1的SayHello方法
System.Console.WriteLine(myDelegate1());
//输出结果为hello  the  world!  与调用myClass1.SayHello();效果相同
}
}
如果代表元只有这点功能它就没有什么太大的用处了,代表元还有一个非常有用的功能就是定义复合代表元对象只有同样类型的代表元才能够复合起来  +  能定义复合代表元对象  -  从一个复合代表元中去掉一个代表元对象
delegate  void  MyDelegate(string  s);
public  class  MyClass
{
public  void  SayHello(string  who)
{
System.Console.WriteLine(  who+"hello!");
}
public  void  SayGoodBye(string  who)
{
System.Console.WriteLine(  who+"good  bye!");
}

}

public  class  TestMyClass
{
public  static  void  Main(string[]  args)
{
MyClass  myClass1=new  MyClass();
MyDelegate  myDelegate,myDelegate1;
myDelegate=new  MyDelegate(myClass1.SayHello);
myDelegate1=new  MyDelegate(myClass1.SayGoodBye);
myDelegate+=myDelegate1;
//这样调用myDeletage就相当于同时调用了myClass1.SayHello和myClass1.SayGoodBye
myDelegate("love.net  ");
//执行结果输出love.net  hello!  love.net  good  bye!
}
}
事件驱动是windows应用程序的重要特征  C#代表元就是用于产生事件,事件就是用于在一个组件中监听这个组件的变化
下面再举一个简单的例子
//定义一个事件代理(代表元)
public  delegate  void  EventHandler(string  str);
//定义事件源类
class  EventSource
{
//定义代表元作为事件源类的成员
public  event  EventHandler  Say;
public  void  TriggerEvent()
{
if(this.Say!=null)
//因为Say是个代表元所以执行Say方法所做的实际操作由注册到它的事件处理函数决定
Say("A  event  take  place!");
}
}
//测试
class  Test
{
public  static  void  Main()
{
EventSource  aEventSource=new  EventSource();
//注册事件处理函数为MyEvent  显示一串字符类似于this.Click+=new  EventHandler(Button1_OnClick);
aEventSource.Say+=new  EventHandler(MyEvent);
//此处为演示事件触发过程所以就用程序自动触发
//在图形界面应用程序中,一般由用户触发事件,后由操作系统发送消息并调用处理函数  所以程序员只要注册事件处理函数
//和编写事件处理函数的代码其他就不用关心了
aEventSource.TriggerEvent();
}
//事件处理函数
public  static  void  MyEvent(string  str)
{
System.Console.WriteLine(str);
}

}


浅析Visual 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控件会自动帮你生成相关的许多代码,但是知道了其内部的工作机制的话总归是有很大益处的,对吗?

C#中动态创建控件及事件处理程序

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

namespace Miner
{
/// <summary>
/// Summary des cription for Form1.
/// </summary>
public class Form1 : System.Windows.Forms.Form
{
 private System.Windows.Forms.Panel panel1;
 /// <summary>
 /// Required designer variable.
 /// </summary>
 ///

 private Button[] n =new Button[100];
 private int[] kn=new int[100];

 private System.ComponentModel.Container components = null;

 public Form1()
 {
  //
  // Required for Windows Form Designer support
  //
  InitializeComponent();

  //
  // TODO: Add any constructor code after InitializeComponent call
  //
 }

 /// <summary>
 /// Clean up any resources being used.
 /// </summary>
 protected override void Dispose( bool disposing )
 {
  if( disposing )
  {
  if (components != null)
  {
   components.Dispose();
  }
  }
  base.Dispose( disposing );
 }

 #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.panel1 = new System.Windows.Forms.Panel();
  this.SuspendLayout();
  //
  // panel1
  //
  this.panel1.Location = new System.Drawing.Point(8, 8);
  this.panel1.Name = "panel1";
  this.panel1.Size = new System.Drawing.Size(400, 400);
  this.panel1.TabIndex = 0;
  //
  // Form1
  //
  this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
  this.BackColor = System.Drawing.Color.White;
  this.ClientSize = new System.Drawing.Size(416, 413);
  this.Controls.AddRange(new System.Windows.Forms.Control[] {
          this.panel1});
  this.Name = "Form1";
  this.Text = "Form1";
  this.Load += new System.EventHandler(this.Form1_Load);
  this.ResumeLayout(false);

 }
 #endregion

 /// <summary>
 /// The main entry point for the application.
 /// </summary>
 [STAThread]
 static void Main()
 {
  Application.Run(new Form1());
 }

 private void Form1_Load(object sender, System.EventArgs e)
 {
  int a=0;
  int x=0,y=0;
  for (a=0;a<=99;a++)
  {
  n[a] = new Button();
  n[a].BackColor =Color.White;
  n[a].FlatStyle = FlatStyle.Flat;
  n[a].Width = panel1.Width / 10;
  n[a].Left = x * n[a].Width;
  n[a].Height = panel1.Height / 10;
  n[a].Top = y * n[a].Height;
  n[a].Name = "b" + a;
  panel1.Controls.Add(n[a]);
  panel1.Controls[a].MouseDown  += new MouseEventHandler(this.ButtonArray_OnClick);
  
  


  x += 1;
  if (x == 10)
  {
   x = 0;
   y += 1;
  }
  }

 

 }

 private void ButtonArray_OnClick(object sender, MouseEventArgs e)
 {
  MouseEventArgs arg=(MouseEventArgs)e;
      Button b1=(Button)sender;
  if (arg.Button==MouseButtons.Right )
  b1.BackColor=Color.White ;
  else
  {
  //b1.BackColor =Color.White ;
  b1.Image=Image.FromFile("f://my documents//my pictures//elements//regular_smile.gif");
  }
 
 }
}
}

C#中的delegate和event

作者: sam1111

  在基于Windows平台的程序设计中,事件(event)是一个很重要的概念。因为在几乎所有的Windows应用程序中,都会涉及大量的异步调用,比如响应点击按钮、处理Windows系统消息等,这些异步调用都需要通过事件的方式来完成。即使在下一代开发平台——.NET中也不例外。



那么什么是事件呢?所谓事件,就是由某个对象发出的消息,这个消息标志着某个特定的行为发生了,或者某个特定的条件成立了。比如用户点击了鼠标、socket上有数据到达等。那个触发(raise)事件的对象称为事件的发送者(event sender),捕获并响应事件的对象称为事件的接收者(event receiver)。



在这里,我们将要讨论的是,在.NET的主流开发语言C#中如何使用自定义的事件来实现我们自己的异步调用。



在C#中,事件的实现依赖于delegate,因此我们有必要先了解一下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. 在要实现异步调用的地方,通过上一步创建的对象来调用方法。



下面是一个简单的例子:







using System;



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



了解了delegate,下面我们来看看,在C#中对事件是如何处理的。



在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!



小结



通过上面的讨论,我们大体上明白了delegate和event的概念,以及如何在C#中使用它们。我个人认为,delegate在C#中是一个相当重要的概念,合理运用的话,可以使一些相当复杂的问题变得很简单。有时我甚至觉得,delegate甚至能够有指针的效果,除了不能直接访问物理地址。而且事件也是完全基于delegate来实现的。由于能力有限,本文只是对delegate和event的应用作了一个浅显的讨论,并不深入,我希望本文能够起到抛砖引玉的作用。真正想要对这两个概念有更深入的了解的话,还是推荐大家看MSDN。

C#里的委托和事件实现Observer

一、委托的简介

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

如果这三个要素都满足的话,则你就写出了一个完整事件的处理。

0 0

相关博文

我的热门文章

img
取 消
img