自定义事件类型

/*

*

* 自定义事件类型

*

*

*

* 摘抄于:<Microsoft.net框架设计>

* email:suiqirui1987@163.com

*

* QQ:492732033

*

* copyright:@@@@ suiqirui19872005.cnblogs.com

*

*

*

* 思想:

*

* 让每个对象都保存一个事件/委托对的集合(通常为一个散列表).当一个新的对象

*

* 被构造时.该集合是空的.当有事件被登记时.我们将在集合中查找该事件

*

* .如果集合中存在该事件.那新的委托实例将衩组全到表示该事件的委托链表上.否则,该事件和新的委托实例将直接被

*

* 添加到集合中..

*

*

* 当事件需要触发时,我们还是首先在集合中查找该事件.如果集合不存在该事件.也就是说

*

* 该事件没有被登记.那么将没有任何委托实例被调用..如果集合中存在该事件.

*

* 那么其对应的委托链表将被调用

*

*

*

*/

 

 

 

using System;

using System.Data;

using System.Configuration;

using System.Web;

using System.Web.Security;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

using System.Web.UI.HtmlControls;

using System.Collections;

using System.Runtime.CompilerServices;

 

#region EventHandlerSet类

 

 

/*

* --------> EventHandlerSet类 <-----------

*

* 注意：

* FCL中定义有一个名为System.ComponentModel.EventHandlerList的类型。该类型和上面展示的EventHandlerSet

*

* 类型所做的事情基本上是一样的。System.Window.Forms.Control和System.Web.UI.Control 类型在维护它们各自的稀疏事件集合时

*

* 使用的就是EventHandlerList这个类型。。 大家当然可以选择使用FCl中EventHandlerList 类型。该类型和我们上面展示的EventHandlerSet

*

* 类型的不同之处在于EventHandlerList类型在内部使用的是一个链表，而不是散列表

*

* 这意味着访问EventHandlerList类型中的元素要比访问EventHandlerSet类型中的元素慢一些.

*

* 另外.EventHandlerList类型没有提供任何线程安全的访问方式.因此在某些情况下.

*

* 大家还需要自已实现一个对EventHandlerList类型的线程安全的封装

*

*

*

*

*/

public class EventHandlerSet : IDisposable

{

//用于保存"事件键/委托值"对的私有散列表

private Hashtable events = new Hashtable();

//一个索引器，用获取或设置与传入的事件对象的

//散列键相关联的委托

public virtual Delegate this[Object eventKey] {

//如果对象不在集合中，则返回null

get {

 

return (Delegate)events[eventKey];

}

set {

 

events[eventKey] = value;

}

}

 

//指定的事件对象的散列刍对应的委托链表上添加/组全一个委托实例

public virtual void AddHandler(object eventKey, Delegate handler) {

 

events[eventKey] = Delegate.Combine((Delegate)events[eventKey], handler);

}

public virtual void RemoveHandler(Object eventKey, Delegate handler) {

 

events[eventKey] = Delegate.Remove((Delegate)events[eventKey], handler);

}

//在指定的事件对象散列键盘对应的委托链表上触发事件

public virtual void Fire(Object eventKey, Object sender, EventArgs e) {

 

Delegate d = (Delegate)events[eventKey];

 

if (d != null) {

 

d.DynamicInvoke(new object[] { sender, e });

}

}

 

//释放对象以使散列表占用的内存资源在下一次垃圾收集中被回收，从而阻止垃圾收集器提升其性能

 

public void Dispose()

{

 

events = null;

 

 

 

}

 

 

//下而的静态方法返回一个对传入的EventHandlerSet对象的线程安全的封装

public static EventHandlerSet Syschronized(EventHandlerSet eventHandlerSet)

{

 

if (eventHandlerSet == null)

{

 

throw new ArgumentNullException("eventHanlderSet");

}

return new SysnchronizedEventHandlerSet(eventHandlerSet);

 

}

 

//下面类在EventHandlerSet类的基础上提供了一个线程安全的封装

private class SysnchronizedEventHandlerSet : EventHandlerSet{

 

//引用非线程安全的对象

private EventHandlerSet eventHandlerSet;

 

 

//在非线程安全的对象上构造一个线程安全的封装

public SysnchronizedEventHandlerSet(EventHandlerSet eventHandlerSet){

 

 

this.eventHandlerSet=eventHandlerSet;

Dispose();//释放基类中的散列表对象

}

 

 

 

//线程安全的索引器

public override Delegate this[object eventKey]

{

 

[System.Runtime.CompilerServices.MethodImpl(MethodImplOptions.Synchronized)]

get

{

return eventHandlerSet[eventKey];

 

}

[MethodImpl(MethodImplOptions.Synchronized)]

set

{

eventHandlerSet[eventKey] = value;

 

 

}

}

 

//线程安全的AddHander方法

[MethodImpl(MethodImplOptions.Synchronized)]

public override void AddHandler(object eventKey, Delegate handler)

{

eventHandlerSet.AddHandler(eventKey, handler);

//base.AddHandler(eventKey, handler);

}

 

//线程安全的RemoveHandler方法

[MethodImpl(MethodImplOptions.Synchronized)]

public override void RemoveHandler(object eventKey, Delegate handler)

{

RemoveHandler(eventKey, handler);

 

//base.RemoveHandler(eventKey, handler);

}

 

//线程安全的Fire方法

 

//该方法首先从events 散列表中找到一个委托链表，然后调用该委托链表上封装的所有的回调方法

/*

* 因为散列表中可能包含有各种各样的不同的委托类型。所以我们不可能在编译进行类型安全

* 的委托调用。因此，我们使用了System.Delegate 的DynamicInvoke方法，交将回调方法的参数

* 组全为一个对象数组传递给它。

* DynamicInvoke方法在内部会检测回调方法期望的参数和我们传递的参数

 

* 是否匹配。如果匹配，回调方法将被调用

*

* 否则。DynamicInvoke方法将抛出一个异常.

*/

public override void Fire(object eventKey, object sender, EventArgs e)

{

eventHandlerSet.Fire(eventKey, sender, e);

//base.Fire(eventKey, sender, e);

}

 

}

 

 

 

}

 

#endregion

 

 

 

#region TypeWithLotsOfEvents类

 

 

/*

* 实现步骤

*

* 1.定义一个受保护的实例集合字段

*

* TypeWithLotsOfEvents类型的每个实例都会使用该集合字段来保存其上的事件侦听者

* 集合.这里的的集合通常使用散列表来实现,因为这可以提供比较快的事件查找速度.集合中的第个元素

* 都有一个键(类型通常为System.Object)用以唯一地标识事件类型.以及一个和刍对应的值用以标识事件

* 触发时要调用的委托链表.将该字段的访问限制设为了protected的目的是让派生类型也可以使用集合来为自已定义的一个类型

* ,它在内部使用了一个System.Collections.Hashtable对象.EventHandlerSet 类型还有一些成员负责处理事件和委托实例

*

*

*

* 2.为类型希望提供的事件定义必要的成员

* 对于我们希望类型提供的每个事件.我们必须为其定义一组成员.大家可以已经注意到了

* 我们没有使用实例字段-----它们正是浪费内存的根源

*

* 2.1 构造一个静态只读对象来标识事件

* 我们必须采取一种方式唯一地标识集合中的每一个事件.因为我们使用的是一个散列表.所以我们需要一个

* 唯一的键.这可以由一个对象的散列码产生.

* TypeWithlotsOfEvents类型的所有实例将共享这个惟一的键.所以我们构造了一个Object,并将其引用保存在一个

* 静态只读字段中.只有在TypeWithlotsOfEvents类型的用户构造多个TypeWithLotsOfEvents.这种技巧才会节省更多的内存.

* 如果用户只构造一个TypeWithLotsOfEvents类型实例.这种技巧实际上会耗费更多的内存.如果是这种情况.就不应该使用这里的

* 演示的技巧.另外,本例中将这个静态字段定义为受保护字段.目的是为了让派生类型也能使用它.当然,大家也可以奖其定义为私

* 有字段.

*

* 2.2 为事件定义一个继承自EventArgs的类型,该类型用于保存任何需要传递给事件接受者的附加信息

* 如果事件没有什么特殊的信息需要传递,我们可以简单的使用FCL中的System.EventArgs类型就可以了.本例仅仅是处于演示的目的

* 因此就没有在其中定义任何字段.

*

* 2.3 定义一个委托类型,指定事件触发时被调用的方法原型

* 由于FooEventArgs类型没有定义任何段,所以实际我们不需要定义一个特殊的委托类型.如果事件没有特殊的信息需要传递给侦听者.

* 我们可以直接使用FCL中定义中System.EventHandler类型;

*

* 2.4 显式定义事件及其访问器方法

* 这个整个技艺中比较有趣的部分,在该步骤中,我们为类型希望提供的每一个事件显式定义了add和remove访问器方法

* add 和remove访问器分别调用了EventHandlerSet类中的AddHandler和RemoveHandler方法.EventHandlerSet类型的AddHandler

* 方法会扫描集合看其中是否存在fooEventKey键对象.如果不存在.它将被添加到散列表中.事件被触发时调用的也将是该键对象

* 所标识的委托实例.如果存在,传入的值(新的委托实例)将被组全到已经存在的委托链表上.RemoveHandler方法所做的操作正好相反.

* 在本例中,所有对EventHandlerSet 集合的访问都是线程安全.所以我们不必再在事件的add和remove访问器方法上指定MethodImpAttribute特性

*

* 2.5 定义一个受保护的虚方法,负责通知事件的登记对象

* 不管何时出现"Foo事件",OnFoo方法都会被调用,在本例中,OnFoo方法调用了EventHandlerSet类型的Fire方法,Fire方法会集合中查找传入

* 键对象.如果找到.它将调用与其相关联的委托链表.其中传递给委托链表的参数为this(触发事件的对象)

* 和表示附加信息的继承自EventArgs的类型实例.

*

* 2.6 定义一个方法将输入转化期望的事件

* 本章前面曾经讨论该方法和它的用法.本例中,我们调用了解SimulateFoo方法来模拟出现了一个"Foo事件".该方法所有工作就是

* 传递必要的附加信息.然后触发事件

*

* 3. 为类型希望提供的事件定义必要的成员

*

*

*/

 

//下面的代码在一个类型中定义多个事件时推荐的设计模式

 

 

class TypeWithLotsOfEvents {

 

//定义一个受保护的实例字段，该字段引用一个集合来管理

//一组事件/委托。注意。类型EventHandlerSet并非们于FCL中，

protected EventHandlerSet eventSet = EventHandlerSet.Syschronized(new EventHandlerSet());

 

/*

* 2.为Foo事件定义必要的成员.

*

* 2.1 构造一个静态的只读对象来标识该事件.每个对象都有

*

* 一个散列码.用于集合中查找事件对应的委托链表

*

*

*

*/

 

protected static readonly Object fooEventKey = new object();

 

/*

* 2.2 为事件定义一个继承自EventArgs类型

*

*

*/

 

public class FooEventArgs:EventArgs

{

 

}

 

/*

*

* 2.3 为事件定义委托原型

*

*/

public delegate void FooEventHandler(Object sender, FooEventArgs e);

 

/*

* 2.4 为事件定义访问器方法用于在集合上添加/移除委托实例

*

*/

 

public event FooEventHandler Foo {

 

add {

 

eventSet.AddHandler(fooEventKey, value);

}

remove {

eventSet.RemoveHandler(fooEventKey, value);

 

}

}

 

 

/*

* 2.5 为事件定义一个受保护的虚方法(OnXXXX)

*

*/

protected virtual void OnFoo(FooEventHandler e) {

 

eventSet.Fire(fooEventKey, this, e);

}

 

 

/*

* 2.6 定义一个方法将输入转化为期望的事件

*

*/

public void SimulateFoo() {

 

OnFoo(new FooEventArgs());

}

 

/*

* 3 为Bar事件定义必要的成员

*

*

* 3.1 构造一个静态只读对象来标识该事件.每个对象都有一个

*

* 散列友用于集合中查找事件对应的委托链表

*/

protected static readonly Object barEventKey = new object();

 

/*

* 3.2 为事件定义一个继承自EventArgs的类型

*

*/

public class BarEventArgs : EventArgs { }

 

 

/*

* 3.3 为事件定义一个委托原型

*/

 

public delegate void BarEventHander(object sender, BarEventArgs e);

 

/*

* 3.4 为事件定义一个受保护的虚方法(Onxxx)

*

*

*/

protected virtual void OnBar(BarEventArgs e) {

 

eventSet.Fire(barEventKey, this, e);

}

 

//3.5 定义一个方法将输入转化为期望事件

 

 

public void SimulateBar() {

OnBar(new BarEventArgs());

}

}

 

#endregion