.NET框架中的委托和事件

.NET框架中的委托和事件

 

现在假设有个案例,一个高档的热水器,当水温超过95度的时候:扬声器开始发出语音,告诉你水的温度;液晶屏也会改变水温的显示,以提示水已经快烧开了.

 

现在需要写这个程序来模拟这个烧水的过程,我们将定义一个类来代表热水器,将它取名为Heater,它代表水温的字段temperature,当然,还有必不可少的水加热方法BoilWater(),一个发出语音警报的方法MakeAlter(),一个显示水温的方法,ShowMsg().

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace NET框架中的委托和事件
{
class Program
{
static void Main(string[] args)
{
Heater ht = new Heater();
ht.BoilWater();
}
}
public class Heater
{
private int temperature;//水温
//烧水
public void BoilWater()
{
for (int i = 0; i < 101; i++)
{
temperature = i;
if (temperature>95)
{
MakeAlert(temperature);
ShowMsg(temperature);
}
}
}
//显示水温
private void ShowMsg(int temperature)
{
Console.WriteLine("水快烧开了,当前为{0}度",temperature);
}
//发出语音警报
private void MakeAlert(int temperature)
{
Console.WriteLine("滴滴滴,水已经{0}度了!",temperature);
}
}
}
 

Observer设计模式简介

 

上面的案例显然能够完成之前描述的工作,但是并不够好.现在假设热水器由三部分组成:烧水器,警报器,显示器.由于它们来自于不同的厂商.那么,烧水器应该仅仅负责烧水,不能发出警报也不能显示水温;在水烧开时由警报器发出警报,显示器显示水温.

 

这个时候上例可能变成下面这样:

//烧水器
public class Heater
{
private int temperature;
//烧水
private void BoilWater()
{
for (int i = 0; i < 101; i++)
{
temperature = i;
}
}
}
//警报器
public class ALarm
{
private void MakeAlert(int param)
{
Console.WriteLine("Alarm:滴滴滴,水已经{0}度了,param");
}
}
//显示器
public class Display
{
private void ShowMsg(int param)
{
Console.WriteLine("Display:水已经烧开,当前温度:{0}度",param);
}
}


 

这里就出现了一个问题:如何在水烧开的时候通知警报器和显示器?在继续进行之前,先了解一下Observer设计模式.Observer设计模式中主要包含如下两类对象:

1.Subject,被监视对象,它往往包含着其他对象所感兴趣的内容.在本实例中,烧水器就是一个被监视对象,它包含的其他对象所感兴趣的内容,就是temperature字段,当这个字段的值快到100时,会不断的把数据发给监视他的对象.

2.Observer,监视者,它监视Subject,当Subject中的某些事件发生的时候,会告知Observer,而Observer则会采取相应的行动.在本示例中,Observer有警报器和显示器,他们才去的行动分别是发出警报和显示水温.

 

 

在本例中,事情发生的顺序应该是这样的:

1.警报器和显示器告诉烧水器,它们对热水器的温度比较感兴趣(注册)

2.烧水器知道后保留对警报器和显示器的引用.

3.烧水器进行烧水这一动作,当水温超过95度时,通过警报器和显示器的引用,自动调用警报器的MakeAlert()方法,显示器的ShowMag()方法.

 

类似这样的例子还有很多,GOF对它进行了抽象,称为Observer设计模式:Observer设计模式是为了定义对象间的一种一对多的依赖关系,以便于当一个对象的状态发生改变时,其他依赖于他的对象会被自动告知并更新.Observer是一种松耦合的设计模式.

 

下面我们就来实现一个Observer设计模式

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace NET框架中的委托和事件
{
class Program
{
static void Main(string[] args)
{
Heater ht = new Heater();
ALarm alarm = new ALarm();

ht.BoilEvent += alarm.MakeAlert;//注册方法
ht.BoilEvent += (new ALarm()).MakeAlert;//为匿名对象注册方法
ht.BoilEvent += Display.ShowMsg;//注册静态方法

ht.BoilWater();//烧水,会自动调用注册过对象的方法
}
}
//烧水器
public class Heater
{
private int temperature;

public delegate void BoilHandler(int param);//声明委托
public event BoilHandler BoilEvent;//声明事件
//烧水
public void BoilWater()
{
for (int i = 0; i < 101; i++)
{
temperature = i;
if (temperature > 95)
{
if (BoilEvent != null)
{
BoilEvent(temperature);
}
}
}
}
}
//警报器
public class ALarm
{
public void MakeAlert(int param)
{
Console.WriteLine("Alarm:滴滴滴,水已经{0}度了", param);
}
}
//显示器
public class Display
{
public static void ShowMsg(int param)
{
Console.WriteLine("Display:水已经烧开,当前温度:{0}度", param);
}
}
}

 

.NET框架中的委托与事件

 

尽管上面的实例很好的完成了我们想要完成的工作,但是还有一个问题没有解决:为什么.NET框架中的事件模型和前面的不同?为啥有很多的EventArgs参数?

 

在回答上述问题之前,首先弄清楚.NET框架的编码规范.

 

委托类型的名称都应该以EventHandler结束

委托的原则定义有一个void返回值,并接受两个输入参数:一个Object类型,一个EventArgs类型(或继承自EventArgs)

事件的命名为委托去掉EventHandler之后剩余的部分.

继承自EventArgs的类型应该以EventArgs结尾.

 

再说明一点:

(1)委托声明原型中的Object类型的桉树代表了Subject,也就是被监视对象,在本例中是Heater(烧水器).回调函数(比如Alarm的MakeAlert)可以通过它访问触发事件的对象(Heater).

(2)EventArgs对象包含了Observer所感兴趣的数据,在本例中temperature.

 

这面这些其实不仅仅是编码规范而已,也使得程序有更大的灵活性.比如,如果不仅想获得热水器的温度,还想在Observer端(警报器或者显示器)方法中获得烧水器的生产日期,型号,价格,那么委托和方法的声明都会变得很麻烦,而如果将热水器的引用传给警报器的方法,就开在方法中直接访问热水器了.

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 符合规范的事件和委托
{
//热水器
public class Heater
{
private int temperature;
public string type = "飞天一号";//添加型号作为演示
public string area = "中国台湾";//天剑产地作为演示

//声明委托
public delegate void BoiledEventHandler(object sender, BoiledEventArgs e);
public event BoiledEventHandler Boiled;//声明委托

//定义BoiledEventArgs类,传递给Observer所感兴趣的信息
public class BoiledEventArgs : EventArgs
{
public readonly int temperature;
public BoiledEventArgs(int temperature)
{
this.temperature = temperature;
}
}

//可以供继承自Heater的类重写,以便继承类拒绝其他对象对它的监视
protected virtual void OnBoiled(BoiledEventArgs e)
{
if (Boiled!=null)//如果有对象注册
{
Boiled(this,e);//调用所有注册对象的方法
}
}

//烧水
public void BoilWater()
{
for (int i = 0; i < 101; i++)
{
temperature = i; if (temperature>95)
{
//建立BoiledEventArgs对象
BoiledEventArgs e = new BoiledEventArgs(temperature);
OnBoiled(e);//调用OnBoiled方法
}
}
}
}
//警报器
public class Alarm
{
public void MakeAlert(object sender, Heater.BoiledEventArgs e)
{
Heater heater = (Heater)sender;
//访问sender中的公共字段
Console.WriteLine("Alarm:{0} - {1}:",heater.area,heater.type);
Console.WriteLine("Alarm:滴滴滴,水已经{0}度了:",e.temperature);
Console.WriteLine();
}
}
//显示器
public class Display
{
public static void ShowMsg(object sender, Heater.BoiledEventArgs e)
{
Heater heater = (Heater)sender;
Console.WriteLine("Display:{0} - {1}:",heater.area,heater.type);
Console.WriteLine("Display:水快烧开了,当前温度:{0}度",e.temperature);
Console.WriteLine();
}
}
class Program
{
static void Main(string[] args)
{
Heater heater = new Heater();
Alarm alarm = new Alarm();
heater.Boiled += alarm.MakeAlert;//注册方法
heater.Boiled += (new Alarm()).MakeAlert;//为匿名对象注册方法
heater.Boiled += new Heater.BoiledEventHandler(alarm.MakeAlert);//也可以这么注册

heater.Boiled += Display.ShowMsg;//注册静态方法
heater.BoilWater();//烧水,会自动调用注册过对象的方法
}
}
}

观察一下输出可以证明我们的三种注册方式都是可以的,这里选择你喜欢的就可以了.