C# 事件

一、前言:前面的随笔中说完了委托,现在看看事件到底可以干什么,在前面的随笔中,使用委托的过程中,有一个很别扭,也很显然易见的问题,就是委托第一次必须初始化用"=",绑定二次事件用"+="这个是非常的,怎么说呢?就是别扭;幸运的是事件就是来解决这个问题(不用初始化,直接使用"+=")的;当然将委托封装成SayHelloManager类中的实例也可以解决这个问题,具体做法参照前面的随笔;

二、概述

1、事件:事件从代码角度看,就是声明了一个委托类型的变量;具体实现代码如下:

using System;
namespace Event{
    public delegate void myEventHandler(string _name);
    class Event1{
       static void Main(string[] args){
            BulidSoftManager bsm=new BulidSoftManager();
            bsm.myevent = BulidByC;   //编译报错  错误详情:Event.BulidSoftManager.myevent只能出现在+=或者-=的左边(在Event.BulidSoftManager中使用除外)
            bsm.myevent+=BulidByCSharp;
            bsm.BulidSoftWalk("OA", bsm.myevent);//上同
       }
       static void BulidByC(string _softName){
             Console.WriteLine(_softName+"  这款软件通过C来编写");
       }
       static void BulidByCSharp(string _softName){
              Console.WriteLine(_softName+"  这款软件通过C#来编写");
       }
    }
    public class BulidSoftManager{
         public event myEventHandler myevent;
         public void BulidSoftWalk(string _softName,myEventHandler bulid){
                bulid(_softName);
         }
    }
}

分析:更具上面的错误提示,这个时候就要借助反编译工具reflactor来看看myevent事件内部的构造;

上面是myevent的基本结构,由两个无返回值的方法(add_myevent和remove_myevent)和一个myevent属性组成。然后点击myevent属性发现下图

恍然大悟,其实myevent事件被编译成了myEventHandler委托的私有委托变量,所以不管你给事件加什么修饰符,最后他都会被编译成目标委托的私有委托变量;

下面是其余两个方法的结构图,贴出来看下:

 好了,根据上面的图解和推断,大致就知道事件的内部大概的运行机制

<1>myevent确实是myEventHandler类型的委托,只不过不管给myevent添加什么修饰符,他都是私有的,因为它会被编译器强制编译成private,

 而add_myevent()和remove_myevent则对应"+="和"-="操作,这两个方法分别用于注册委托类型的方法和取消注册,而这两个方法的访问限制取决于你定义的事件是否对外暴露。

如果你定义的事件是private,那么在外部类中就无法调用这个事件当然也就无法吊用这两个方法;

<2>add_myevent()方法概述

从上图可以看出,在add_myevent()方法内部，实际上调用了System.Delegate的Combine()静态方法，这个方法用于将当前的变量添加到委托链表中。我们前面提到过两次，说委托实际上是一个类;

 

2、综上所述:得出这么几个结论

<1>事件在定义之后,会被编译器编译成委托类型的变量,而这个变量是定义(封装)该事件的类所私有的,当外部类使用该事件时无法进行赋值操作(也就是"="),但是在定义该事件的类中可以使用;

<2>在事件允许访问的情况下,可以对事件进行"+="和"-="操作,原因上文已说明;

三、实例

现在需要设计一个汽车燃油监测系统,当油量小于10升时:

1、汽车警报器报警  -滴滴声

2、仪表盘显示相应的警告信息

using System;

namespace Event
{
    class Program
    {
        static void Main(string[] args)
        {
            Car car = new Car();
            car.drive();
        }
    }
    internal class Car
    {
        private int _oilmass;
        public int OilMass
        {
            set { _oilmass = value; }
            get { return _oilmass; }
        }
        public  void drive()
        {
            for (int OilMass = 10000000; OilMass >= 0; OilMass--)
            {
                if (OilMass < 10)
                {
                    MakeAlark();
                    ShowWarnMsg();
                    break;
                }
            }
        }
        private void MakeAlark()
        {
            Console.WriteLine("滴滴滴~ 油量不足");
        }
        private void ShowWarnMsg()
        {
            Console.WriteLine("油量不足");
        }
    }
}

 上面这段代码显然能很好的完成基本的预警工作,但是从设计角度来说不是很好,因为假设报警器和显示屏来自不同的生产厂商,那么这样的代码就显得耦合度太高了(也就是说让报警器就干报警你的工作,显示器就干显示的工作),下面就来解耦上面的代码。

解耦上面代码需要用到一种设计模式-观察者模式设计模式

简介:Observer设计模式主要包括以下两种对象:

(1)被监视对象:Subject,它往往包含其他对象感兴趣的东西,上面这个例子中油箱中的油就是Subject(被监视对象);

(2)监视对象:Observer,它监视这Subject,当Subject中的某件事发生后,会告知Observer,Obersver会采取相应的行动。上面例子中显示器和报警器就是监视对象,当油箱中油量小于10升时,报警器和显示器就会做出相应的警报;

上面的例子用观察者模式重写的逻辑大致是这样的：

(1)、显示器和报警器告诉油箱,它们对油量比较感兴趣,那么显示器和油箱就在对应的方法中注册油量这个参数

(2)、油箱则保留对显示器报警器中对应方法的引用(通过事件,因为事件可以以委托链的形式来表达,如果单纯的用委托,那么方法只会覆盖)

代码如下:

using System;

namespace  Event
{
    class Obersver
   {
        static void Main(string[] args)
       {
           Oil oil=new Oil();
           Alarm alarm=new Alarm();
           oil.Warn+=alarm.MakeAlarm;
           oil.Warn+=(new Alarm()).MakeAlarm;
           oil.Warn += Display.ShowMsg;
           oil.burn();
        }
   }
   //第一步:构造被监视对象   -油箱
   internal class Oil
   {
       //第二步:定义自身特有的属性
       private int _oilmass;
      
       //第五步:保留对监视对象中方法的使用到自身特有属性方法的引用
       internal delegate void WarnEventHandler(int _oilmass);
       internal event WarnEventHandler Warn;
       
       internal void burn(){
            for(int i=1000;i>=0;i--){
                _oilmass=i;
                if(_oilmass<3){
                   if(Warn!=null){
                      Warn(_oilmass);
                   }
                }
            }
       }
       
   }  
   //第三步:构造监视对象一
   internal class Alarm
   {
       //第四步:注册感兴趣的参数到自定义的方法中
       internal void MakeAlarm(int _oilmass){
           Console.WriteLine("嘀嘀嘀~,油量达到了{0}L", _oilmass);
       }
   } 
   //第三步:构造监视对象二
   internal class Display
   {  
       //第四步:注册感兴趣的参数到自定义的方法中
       internal static  void ShowMsg(int _oilmass)
       {
           Console.WriteLine("油量达到了{0}L", _oilmass);
       }
   } 
}

ok,上面的代码虽然很好的完成了我们提出的需求,但是还是有一点小问题;

(1)、在事件和委托的命名上没有和.NET FrameWork中的保持一致,在.NET FrameWork中委托都应该以EventHandler结尾。事件的命名为委托的名称去掉EventHandler之后的内容。

(2)、上面的代码符合了提出的需求,而且程序的灵活性也大大的提高了,但是如果,我们需要在Observer端(警报器或者显示器)中显示热水器的生产日期、型号、价格等相关属性,日常生活中的这种例子很多,那么现在的代码结构就无法胜任这一需求,因为如果一个两个属性还好,可以通过字段初始化进去,但是如果字段和属性很庞大的话,那么就需要考虑将热水器的引用传递给Observer端(警报器或者显示器)的方式了。解决方案正是.NET Framework经常使用的事件模型。

3、使用.NET Framework的事件模型来解决上面的问题

在解决上面的问题之前,先了解.Net Framework中的委托和事件的编程规范

(1)、委托类型的名称应该以EventHandler结束

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

(3)、事件的命名规范:为委托EventHandler之后剩余的部分

(4)、继承自EventArgs的类型应该以EventArgs结尾

(5)、EventArgs对象包含了Observer端(警报器或者显示器)所感兴趣的数据,在本例是temperature

(6)、Object对象是传递给Observer端(警报器或者显示器)的Subject对象,本例中是热水器对象

ok,介绍完规范之后,开始重构上面的代码,解决上面提出的问题

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

namespace Event
{
    class Program
    {
        static void Main(string[] args)
        {
            Calorifier cr = new Calorifier();
            cr.BoilEvent += new Alarm().MakeAlarm;
            cr.BoilEvent += new Display().ShowMessage;
            cr.BoilWater();
        }
    }
    /// <summary>
    /// 热水器类,观察者模式
    /// </summary>
    public class Calorifier
    {
        public string type = "Bamboo 001";
        public string yieldly = "Tong li";
        public delegate void BoilHandler(Object sender, BoiledEventArgs e);
        public event BoilHandler BoilEvent;
        /// <summary>
        /// 定义BoiledEventArgs类,传递给Observer端(警报器或者显示器)所感兴趣的信息 
        /// </summary>
        public class BoiledEventArgs : EventArgs
        {
            public readonly int Temperature;
            public BoiledEventArgs(int temperature)
            {
                this.Temperature = temperature;
            }
        }
        public void BoilWater()
        {
            for (int i = 0; i < 100; i++)
            {
                if (i >= 95)
                {
                    BoiledEventArgs args = new BoiledEventArgs(i);
                    OnBoiled(args);
                }
            }
        }
        protected void OnBoiled(BoiledEventArgs e)
        {
            BoilEvent(this, e);
        }
    }

    /// <summary>
    /// 报警器
    /// </summary>
    public class Alarm
    {
        public void MakeAlarm(Object sender,Calorifier.BoiledEventArgs e) 
        {
            Calorifier cr = (Calorifier)sender;//拆箱
            Console.WriteLine("Alarm:嘀嘀嘀,水已经 {0} 度了,当前热水器的型号是{1},生产地是{2}", e.Temperature, cr.type,cr.yieldly);
            Console.ReadKey();
        }
    }

    /// <summary>
    /// 显示器
    /// </summary>
    public class Display
    {
        public void ShowMessage(Object sender, Calorifier.BoiledEventArgs e)
        {
            Calorifier cr = (Calorifier)sender;//拆箱
            Console.WriteLine("Display:水已烧开,当前温度:{0}度,当前热水器的型号是{1},生产地是{2}", e.Temperature, cr.type,cr.yieldly);
            Console.ReadKey();
        }
    }
}

ok,完美解决问题,通过拆箱和BoiledEventArgs传递给Observer端(警报器或者显示器)他们所需要的信息。