委托、事件、Observer观察者模式的使用解析二

一、设计模式-Observer观察者模式

Observer设计模式是为了定义对象间的一种一对多的依赖关系,以便于当一个对象的状态改变时,其他依赖于它的对象会被自动告知并更新。Observer模式是一种松耦合的设计模式。

Observer设计模式中主要包括如下两类对象:
Subject:监视对象,它往往包含着其他对象所感兴趣的内容。(如下例中的Boss,需要一直被手下盯着等候他给出指令)
Observer:监视者,它监视Subject,当Subject中的某件事发生的时候,会告知Observer,而Observer则会采取相应的行动。(如下例中的MemberA和B,他们需要一直盯着Boss准备接收指令采取行动)

例:

老大带着小弟去谈判,如果老大举起左手则小A行动,如果老大举起右手则小B行动,如果情况不妙老大摔了杯子则小A小B一起行动。

委托、事件、Observer观察者模式的使用解析二

要完成以上需求,我们知道如果使用传统编码方式会采用,在老大的Boss类中有一个举手()和一个摔杯子()方法,在这个方法中调用小A和小B的行动方法。

public class Boss
{
private MemberA memberA = new MemberA();
private MemberB memberB = new MemberB();
/// <summary>
/// 举手
/// </summary>
/// <param name="hand"></param>
public void Raise(string hand)
{
if (hand == "左")
{
memberA.Attack();
}
else if (hand == "右")
{
memberB.Attack();
}
}
/// <summary>
/// 摔杯子
/// </summary>
public void Fail()
{
memberA.Attack();
memberB.Attack();
}
}
public class MemberA
{
public void Attack()
{
//do something...
}
}
public class MemberB
{
public void Attack()
{
//do something...
}
}

好了,我们按照这种方式完成了编码,此时需求变更了,对方人数过多我们需要多带些人手,增加MemberC、MemberD,就要在Boss类中频繁的修改Raise()和Fail(),使程序毫无扩展性,那么我们改为事件委托的方式试试看。

#region 观察者模式
/// <summary>
/// 左/右手
/// </summary>
public enum Hand
{
Left,
Right
}
/// <summary>
/// 监视对象
/// </summary>
public class Boss
{
//我要举起的手
public Hand MyHand { get; set; }
//举手-委托-事件
public delegate void RaiseDelegate(Hand myHand);
public event RaiseDelegate RaiseEventHandler;
//摔杯子-委托-事件
public delegate void FailDelegate();
public event FailDelegate FailEventHandler; public void RaiseHand()
{
Console.WriteLine("举手-" + MyHand);
if (RaiseEventHandler != null)
{
RaiseEventHandler(MyHand);
}
}
public void FailAll()
{
Console.WriteLine("摔杯子");
if (FailEventHandler != null)
{
FailEventHandler();
}
}
}
/// <summary>
/// 监视者A
/// </summary>
public class MemberA
{
public void HandLeft(Hand myHand)
{
if (myHand == Hand.Left)
Attack();
}
public void Attack()
{
Console.WriteLine("MemberA攻击");
}
}
/// <summary>
/// 监视者B
/// </summary>
public class MemberB
{
public void HandRight(Hand myHand)
{
if (myHand == Hand.Right)
Attack();
}
public void Attack()
{
Console.WriteLine("MemberB攻击");
}
}
#endregion
#region 调用代码

Boss boss = new Boss();
MemberA memberA = new MemberA();
MemberB memberB = new MemberB(); boss.RaiseEventHandler += memberA.HandLeft;
boss.FailEventHandler += memberA.Attack; boss.RaiseEventHandler += memberB.HandRight;
boss.FailEventHandler += memberB.Attack; boss.MyHand = Hand.Left;
boss.RaiseHand();
boss.FailAll(); #endregion

改造完成,又有需求变更了,增加老大带的人手,此时我们主类Boss类不需要进行任何修改,只需要增加新的小弟类MemberC、MemberD等等即可,这样也实现了“对扩展说Yes,对修改说No”的宗旨。

二、.Net中的事件与委托

仔细看会发现,我们写的和.Net中自带的委托事件不太一样,尤其是Webform时的那些按钮事件

委托、事件、Observer观察者模式的使用解析二

首先.Net有几条编码规范:

1、委托类型的名称都应该以EventHandler结尾

2、委托的原型定义,要无返回值void,要有两个输入参数,一个object类型,一个EventArgs类型(或继承EventArgs)

3、事件的名称为委托去掉EventHandler剩余的部分

4、继承EventArgs的子类名称都应以EventArgs结尾

结合我们的例子解释一下:

1、委托声明原型参数中object对象代表了Subject,也就是监视对象,本例中就是Boss自己,注册委托的方法(MemberA)中可以访问触发事件的对象(Boss)

2、EventArgs对象代表了Observer,也就是监视者,其中包含了监视者所需要的数据,本例中就是举起的那只手左还是右

这样的设计并不是硬套编码规范,它还具有很强的灵活性,如果需要在Observer下显示Subject的信息,比如想显示出手(MemberA)下保护了那个老大(Boss.Name),就需要在委托方法中增加很多参数,而这样我们直接

把Boss对象引用传递给MemberA的方法,就可以根据自己的需求直接访问Boss了

#region 观察者模式
/// <summary>
/// 左/右手
/// </summary>
public enum Hand
{
Left,
Right
}
/// <summary>
/// 监视对象
/// </summary>
public class Boss
{
//我的手
public Hand MyHand { get; set; }
//我的名字
public string MyName
{
get { return "Taiyonghai"; }
}
//举手-委托-事件
public delegate void RaiseEventHandler(object sender, RaiseEventArgs e);
public event RaiseEventHandler Raise;
//举手事件参数对象(此对象就是为了整合所有监视者关心的属性,便于直接传递给监视者使用,也就是监视者需要什么字段就定义什么字段)
public class RaiseEventArgs : EventArgs
{
public Hand myHand;
public RaiseEventArgs(Hand myHand)
{
this.myHand = myHand;
}
}
//举手后需要执行事件方法(执行是否调用已注册到此事件上的方法,设为虚方法为继承此类的子类提供的可重写的能力,
//以便子类自己选择是否接受监视并调用已注册方法,或者不被监视不调用任何方法)
public virtual void OnRaiseHand(RaiseEventArgs e)
{
if (Raise != null) //有否已有注册方法
{
Raise(this, e); //调用所有已注册的方法
}
}
//举手方法
public void RaiseHand()
{
Console.WriteLine("举手-" + MyHand);
RaiseEventArgs e = new RaiseEventArgs(MyHand);
OnRaiseHand(e);
} //摔杯子-委托-事件
public delegate void FailEventHandler(object sender);
public event FailEventHandler Fail;
//摔杯子需要执行事件方法
public virtual void OnFailAll()
{
if (Fail != null)
{
Fail(this);
}
}
//摔杯子方法
public void FailAll()
{
Console.WriteLine("摔杯子");
OnFailAll();
}
}
/// <summary>
/// 监视者A
/// </summary>
public class MemberA
{
public void HandLeft(object sender, Boss.RaiseEventArgs e)
{
Boss boss = (Boss)sender;
if (e.myHand == Hand.Left)
Console.WriteLine("MemberA单独行动,保护" + boss.MyName);
}
public void Attack(object sender)
{
Boss boss = (Boss)sender;
Console.WriteLine("MemberA一起行动,保护" + boss.MyName);
}
}
/// <summary>
/// 监视者B
/// </summary>
public class MemberB
{
public void HandRight(object sender, Boss.RaiseEventArgs e)
{
Boss boss = (Boss)sender;
if (e.myHand == Hand.Right)
Console.WriteLine("MemberB单独行动,保护" + boss.MyName);
}
public void Attack(object sender)
{
Boss boss = (Boss)sender;
Console.WriteLine("MemberB一起行动,保护" + boss.MyName);
}
}
#endregion
#region 调用代码

Boss boss = new Boss();
MemberA memberA = new MemberA(); boss.Raise += memberA.HandLeft; //普通注册方法(也可以静态方法注册)
boss.Fail += memberA.Attack; boss.Raise += new MemberB().HandRight; //匿名对象注册方法
boss.Fail += new MemberB().Attack; boss.MyHand = Hand.Left;
boss.RaiseHand();
boss.FailAll(); #endregion

参照别人的讲解,编写了这个小Demo,总算是理解了委托、事件、Observer设计模式及.Net规范下的委托事件写法,重点还是要应用到工作当中才能真正把知识变成自己的

继续共享出我参照的文章地址:http://www.tracefact.net/CSharp-Programming/Delegates-and-Events-in-CSharp.aspx

还有一篇解释细节的文章,我还没有时间看,先做个记录,文章地址:http://www.tracefact.net/CSharp-Programming/Delegates-and-Events-Advanced.aspx

上一篇:JVM调优总结


下一篇:[Javascript] Manipulate the DOM with the classList API