C＃事件机制归纳

 C＃事件机制归纳

   1.委派的实现过程。
首先来看一下委派，委派其实就是方法的传递，并不定义方法的实现。事件其实就是标准化了的委派，为了事件处理过程特制的、稍微专业化一点的组播委派（多点委派）。下面举一个例子，我觉得把委派的例子和事件的例子比较，会比较容易理解。
using System;
 
class Class1
{
       delegate int MathOp(int i1,int i2);
       static void Main(string[] args)
       {
               MathOp op1=new MathOp(Add);
               MathOp op2=new MathOp(Multiply);
               Console.WriteLine(op1(100,200));
              Console.WriteLine(op2(100,200));
               Console.ReadLine();
       }
       public static int Add(int i1,int i2)
       {
               return i1+i2;
       }
       public static int Multiply(int i1,int i2)
       {
              return i1*i2;
       }
}
 
首先代码定义了一个委托MathOp,其签名匹配与两个函数Add()和Multiply()的签名(也就是其带的参数类型数量相同):
delegate int MathOp(int i1,int i2);
Main()中代码首先使用新的委托类型声明一个变量,并且初始化委托变量.注意,声明时的参数只要使用委托传递的函数的函数名,而不加括号:
MathOp op1=new MathOp(Add);
(或为MathOp op1=new MathOp(Multiply);)
委托传递的函数的函数体:
public static int Add(int i1,int i2)
{
       return i1+i2;
}
public static int Multiply(int i1,int i2)
{
      return i1*i2;
}
然后把委托变量看作是一个函数名,将参数传递给函数。 Console.WriteLine(op1(100,200));
Console.WriteLine(op2(100,200));
 
 
2．事件的实现过程
using System;
 
class Class1
{
       static void Main(string[] args)
       {
               Student s1=new Student();
               Student s2=new Student();
               s1.RegisterOK +=new Student.DelegateRegisterOkEvent(Student_RegisterOK);
               s2.RegisterOK +=new Student.DelegateRegisterOkEvent(Student_RegisterOK);
               s1.Register();
               s2.Register();
               Console.ReadLine();
       }
       static void Student_RegisterOK()
       {
              Console.WriteLine("Hello");
       }
}
 
class Student
{
       public delegate void DelegateRegisterOkEvent();
       public event DelegateRegisterOkEvent RegisterOK;
       public string Name;
       public void Register()
       {
               Console.WriteLine("Register Method");
              RegisterOK();
       }
}
在Student类中，先声明了委托DelegateRegisterOkEvent()，然后使用event和要使用的委托类型（前面定义的DelegateRegisterOkEvent委托类型）声明事件RegisterOK（可以看作是委托的一个实例。）：
public delegate void DelegateRegisterOkEvent();
public event DelegateRegisterOkEvent RegisterOK;
然后在Main（）函数中，实例化Student类，然后s1.RegisterOK事件委托给了Student_RegisterOK 方法。通过“+=”（加等于）操作符非常容易地为.Net对象中的一个事件添加一个甚至多个响应方法；还可以通过非常简单的“-=”（减等于）操作符取消这些响应方法。
然后，当调用s1.Register()时，事件s1.RegisterOK发生。

   3．C#中预定义事件处理方式
    学习事件,我觉得最不好理解的就是C#中预定义了事件,使我才开始学习事件时一头雾水。在查了些资料后，终于弄明白了一些，如下：
EventArgs是包含事件数据的类的基类,用于传递事件的细节。
EventHandler是一个委托声明如下（其在.Net类库中如下声明的）
public delegate void EventHandler( object sender , EventArgs e ) 所以，所有形如: 
void 函娄名(object 参数名,EventArgs 参数名);
的函数都可以作为Control类的Click事件响应方法了。如下面所定义的一个事件响应方法：
private void button1_Click(object sender, System.EventArgs e)
参数object sender表示引发事件的对象，（其实这里传递的是对象的引用，如果是button1的click事件则sender就是button1）System.EventArgs e 代表事件的相应信息，如鼠标的x,y值等。
下面我们研究一下Button类看看其中的事件声明，以Click事件为例。
public event EventHandler Click;
这里定义了一个EventHandler类型的事件Click
private void button1_Click(object sender, System.EventArgs e)
         {
                   ...
             }
这是我们和button1_click事件所对应的方法。注意方法的参数符合委托中的签名（既参数列表）。那我们怎么把这个方法和事件联系起来呢，请看下面的代码。
this.button1.Click += new System.EventHandler(this.button1_Click); （其实button1.Click 为System.EventHandler委派的实例事件。与委派中委派实例委托给某一方法非常相似）
把this.button1_Click方法绑定到this.button1.Click事件。
 
 
4．事件的参数的使用。
using System;
 
class Class1
{
       static void Main()
       {
               Student s1=new Student();
               s1.Name ="Student1";
               Student s2=new Student();
               s2.Name ="Student2";
              s1.RegisterOK +=new Student.DelegateRegisterOkEvent(Student_RegisterOK);
               s2.RegisterOK +=new Student.DelegateRegisterOkEvent(Student_RegisterOK);
 
               //当Register方法一执行，触发RegisterOK事件
               //RegisterOK事件一触发，然后执行Student_RegisterOK方法
               s1.Register();  
              s2.Register();
              Console.ReadLine();
       }
       static void Student_RegisterOK(RegisterOkArgs e)
       {
              Console.WriteLine(e.EventInfo);
       }
}
 
class Student
{
       public delegate void DelegateRegisterOkEvent(RegisterOkArgs e);
       public event DelegateRegisterOkEvent RegisterOK;
       public string Name;
       public void Register()
       {
              Console.WriteLine("Register Method");
              RegisterOK(new RegisterOkArgs("Student Name: "+Name));
       }
}
class RegisterOkArgs:EventArgs
{
       public string EventInfo;
       public RegisterOkArgs(string eventInfo):base()
       {
              this.EventInfo =eventInfo;
       }
}

 

C#-委托

对学过c/c++的来说，delegate就相当于函数指针，看下面的代码：

class Person

{

public Person(string name)

{

this.name=name;

}

//一些属性和方法

string name;

public void Eat(Food food);

}

Person类有一个Eat方法，对它的实例来说，张三，李四，王五都有他们自己的Eat方法

Person zhanSan,liSi,wangWu;

zhanSan=new Person(”张三”）;

liSi=new Person(”李四”);

wangWu=new Person(”王五”);

我们可以通过定义一个委托来分别调用Eat方法

public void delegate Eat(Food food);

如果想调用zhanSan.Eat(food)

Eat zhanSanEat=new Eat(zhanSan.Eat)；

其他类似：

Eat liSiEat=new Eat(liSi.Eat)；

Eat wangWu=new Eat(wangWu.Eat)；

这样调用zhanSanEat(food)就相当于调用zhanSan.Eat(food)

委托最有用的是委托链，如果张三，李四，王五共同进餐

则可以定义委托如下

//定义复合委托

Eat togetherEat;

//c＃中通过“＋“将方法Connect到委托,即将委托加到委托链中

//通过“－”将方法从委托链中删除

togetherEat=zhanSanEat+liSiEat+wangwuEat;

//张三，李四，王五一起吃西瓜

togetherEat(西瓜）；

//不带张三，只有李四和王五吃

togetherEat=liSiEat+wangWuEat;

togetherEat(西瓜）；

.net中的事件机制就是通过委托来实现的。

下面是C＃技术揭密上的一段源代码,我加了一些注释，讲解了事件的实现机制

//InventoryManager类用于更新库存量，它也定义了当更新库存量时应该触发的事件，也就是说它发布一个委托由订阅者调用
//InventoryWatcher类定义的是订阅者，可以选择是否将自己添加到发布者的列表中，从而在更新库存时，得到通知
using System;

namespace DelegateEvents
{
//定义EventArgs的派生类，用来携带事件信息
class InventoryChangeEventArgs:System.EventArgs
{
public InventoryChangeEventArgs(string sku,int change)
{
this.sku=sku;
this.change= change;
}
string sku;
public string Sku
{
get{return sku;}
}
int change;
public int Change
{
get{return change;}
}
}
//发布者
class InventoryManager
{
//声明一个委托，两个参数必不可少，第一个是发布者对象，第二个一定要是EventArgs类或者其派生类
public delegate void InventoryChangeEventHandler(object source,InventoryChangeEventArgs e);
//定义该委托的事件实例(即委托链，用于订阅者将自己加到委托链中
public event InventoryChangeEventHandler OnInventoryChangeHandler;
//InventoryManager的方法，用于更新库存
public void UpdateInventory(string sku,int change)
{
if(0==change)
return;
//定义事件参数实例，传递sku和change信息
InventoryChangeEventArgs e=new InventoryChangeEventArgs(sku,change);
//判断委托链表是否为空，如果不空，说明有订阅者订阅
if(this.OnInventoryChangeHandler!=null)
{
Console.WriteLine("[InventoryManager.UpdateInventory] Raising event to all subscribers.../n");
//依次调用委托链表上的方法
this.OnInventoryChangeHandler(this,e);
}
}
}
//订阅者
class InventoryWatcher
{
//定义发布者
InventoryManager invnetoryManager;
public InventoryWatcher(InventoryManager inventoryManager)
{
Console.WriteLine("[InventoryWatcher.InventoryWatcher] Subscribing to InventoryChange event/n");
this.invnetoryManager=inventoryManager;
//将自己Connect到InventoryManager.InventoryChangeEventHandler委托
inventoryManager.OnInventoryChangeHandler+=new InventoryManager.InventoryChangeEventHandler(OnInventoryChange);
}
//订阅者的方法，用于在发布者更新库存量时调用
void OnInventoryChange(object source,InventoryChangeEventArgs e)
{
int change=e.Change;
Console.WriteLine("[InventoryManager.OnInventoryChange]/n/tPart'{0}' was {} by {} units/n",e.Sku,change>0?"increased":"decreased",Math.Abs(e.Change));
}
}
/// <summary>
/// 用委托实现事件机制实例
/// </summary>
class DelegateEvents
{
/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main(string[] args)
{
//定义委托发布者对象
InventoryManager inventoryManager=new InventoryManager();

Console.WriteLine("[DelegateEvents.Main Instantiating subscriber object/n");
//定义订阅者对象
InventoryWatcher inventWatcher=new InventoryWatcher(inventoryManager);
inventoryManager.UpdateInventory(" 006 6",);
inventoryManager.UpdateInventory(" 00 8",);

Console.ReadLine();
}
}
}