从多播委托到事件

一、多播委托

前文提到的委托只是在一个委托类型中存储了一个方法（函数），实际上一个委托变量可以同时绑定多个方法，这些委托形成了一个委托链，每一个委托（实际上是方法）都顺序指向下一个委托，这个委托链就是多播委托。

每一个绑定的方法就像是订阅者一样，等着发布者的消息，而触发委托变量的那个就像是发布者，将出发的信号传给所有的订阅者。

1、订阅者

考虑一个温度控制器的例子，这个控制器拥有两个调温器，一个加热器，当温度低于指定的值时，启动，一个冷却器，当温度高于指定的温度时，启动。二者的类设计如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//订阅者
namespace DuoBoEvent
{
    class Heater
    {
        public Heater(float temperature)//设定启动加热器的临界
        {
            Temperature = temperature; 
        }
        private float _Temperature;

        public float Temperature
        {
            get { return _Temperature; }
            set { _Temperature = value; }
        }
        public void OnTemperatureChanged(float newTemperature)
        {
            if (newTemperature < Temperature)
            {
                Console.WriteLine("Heater start");
            }
            else
            {
                Console.WriteLine("Heater stop");
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//订阅者
namespace DuoBoEvent
{
    class Cooler
    {
        private float _Temperature;//启动Cooler的临界温度

        public float Temperature
        {
            get { return _Temperature; }
            set { _Temperature = value; }
        }
        public Cooler(float temperature)
        {
            Temperature = temperature;
        }

        public void OnTemperatureChanged(float newTemperature)//传入的为当前温度
        {
            if (newTemperature > Temperature)
            {
                Console.WriteLine("Cooler start");
            }
            else
            {
                Console.WriteLine("Cooler stop");
            }
        }
    }
}

可以看出，这两个类除了温度比较外，几乎完全一致，温度比较的那个函数，形式也是一致的。OnTemperatureChanged都属于订阅者方法，他们的参数类型与发布者的委托类型一致，这样才可以绑定到发布者的委托变量上。

2、发布者

发布者代码如下：

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

namespace DuoBoEvent
{//发布者
    class Thermostat
    {
        public delegate void TemperatureChangedHandler(float newTemperature);//定义一个委托，他与订阅者的函数签名一致

        //定义一个委托类型的成员，用来发布“消息”
        private TemperatureChangedHandler _OnTemperatureChange;

        public TemperatureChangedHandler OnTemperatureChange
        {
            get { return _OnTemperatureChange; }
            set { _OnTemperatureChange = value; }
        }
        //定义这个属性，在其访问器内出发委托，作为发布
        private float _CurrentTemperature;

        public float CurrentTemperature
        {
            get { return _CurrentTemperature; }
            set 
            {
                if (value != CurrentTemperature)
                {
                    //其实，_CurrentTemperature已经是输入新的温度后的前温度了，用来与新的温度Value比较，下一句就是更新前温度为现温度
                    _CurrentTemperature = value;//用作一个参数，类似 public void OnTemperatureChanged(float newTemperature)里面的参数
                    //调用委托
                    OnTemperatureChange(value);//如果温度不一致再调用
                } 
                 
            }
        }

    }
}

可以看出，在_CurrentTemperature的访问器内调用了这个委托变量，如果我在主函数中将两个调节器的OnTemperatureChanged与Thermostat的委托变量绑定后，当执行到_CurrentTemperature的访问器后，通过判定，会调用委托。

3、主函数：

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

namespace DuoBoEvent
{
    class Program
    {
        static void Main(string[] args)
        {
            Heater heater = new Heater(60);
            Cooler cooler = new Cooler(80);
            Thermostat thermostat = new Thermostat();
            string temperature;
            //订阅者与发布者绑定
            thermostat.OnTemperatureChange += heater.OnTemperatureChanged;
            thermostat.OnTemperatureChange += cooler.OnTemperatureChanged;
            //读入当前温度,60及其以下会出发Heater，80及其以上，会出发Cooler
            Console.WriteLine("Enter the current temperature");
            temperature = Console.ReadLine();
            thermostat.CurrentTemperature = int.Parse(temperature);
        }
    }
}

在最后一句，在赋值的同时（实际上是晚于复制），调用了委托，便可以看到两个调节器的状态。

二、对发布者调用委托变量的考虑

如果我在主函数中没有给Thermostat的委托变量指定任何方法呢？会提示委托对象未实例化，所以在调用前必须要进行空值检查，代码如下：

  if (value != CurrentTemperature)
                {
                    //其实，_CurrentTemperature已经是输入新的温度后的前温度了，用来与新的温度Value比较，下一句就是更新前温度为现温度
                    _CurrentTemperature = value;//用作一个参数，类似 public void OnTemperatureChanged(float newTemperature)里面的参数
                    //调用委托
                    TemperatureChangedHandler localOnChange = OnTemperatureChange;
                    if (localOnChange != null)
                    {
                        OnTemperatureChange(value);//如果温度不一致再调用
                    }   
                } 

需要注意的是，并没有直接检查OnTemperatureChange，而是将其赋值给了localOnChange，因为可能在判断的时候，其他线程置空了OnTemperatureChange，造成错误。

既然委托是引用类型，那么为什么置空OnTemperatureChange不会影响到localOnChange呢？因为C#中，删除订阅者通过-=运算符，而调用-=来处理OnTemperatureChange-=<listener>，不会从OnTemperatureChange上删除，而是生成了一个全新的委托指向他，所以localOnChange是安全的。

三、BUG的处理。

如果同时绑定了2个方法，但是第一个方法在执行的出现了BUG导致不能正常运行，系统如何处理呢？

解决方法是，在Thermostat中调用委托的时候，对其进行遍历，便可以继续通知后续的方法。

代码如下：

   if (localOnChange != null)
                    {
                        foreach (TemperatureChangedHandler handler in OnTemperatureChange.GetInvocationList())
                        {
                            try
                            {
                                handler(value);
                            }
                            catch (System.Exception ex)
                            {
                                Console.WriteLine(ex.Message);
                            }
                        }
                       // OnTemperatureChange(value);//如果温度不一致再调用

                    }   

若委托有返回值，也需要用遍历循环的方法来处理返回值。

四、事件

从上文可以看到，委托在Main里面可以用+=,也可以用-=，但是有些程序员会不小心将+= -=写成=，而=的机制是，先将左侧的委托变量清空，再将右侧的方法复制给左侧，这样会造成严重的错误。所以有必要对委托进行另一次封装，阻止其在Mian中的=操作。

另外一个问题是，不仅可以在Thermostat中触发事件，也可以main函数中显式的触发事件，如下语句：Thermostat.OnTemperature(42); 这样完全越过了发布者里面的各种判断，容易造成错误。而事件是不允许这样做的。

使用了事件，就成了事件-编码模式，发布者代码改成如下：

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

namespace DuoBoEvent
{
    class ThermostatEvent
    {
        //此类是自定义的参数类
        public class TemperatureAtgs : System.EventArgs
        {
            public TemperatureAtgs(float newTemperature)
            {
                NewTemperature = newTemperature;
            }
            private float _newTemperature;

            public float NewTemperature
            {
                get { return _newTemperature; }
                set { _newTemperature = value; }
            }
        }
        //声明一个委托，符合标准的参数列表
        public delegate void TemperatureChangedHandler(object sender, TemperatureAtgs newTemperature);
        //用事件字段封装一个事件属性
        public event TemperatureChangedHandler OnTemperatureChange = delegate { };//与委托不同，此处声明为了public，看似减弱封装，实际上event给了更强的限制。
        //同多播
        private float _CurrentTemperature;

        public float CurrentTemperature
        {
            get { return _CurrentTemperature; }
            set
            {
                if (value != CurrentTemperature)
                {
                   
                    _CurrentTemperature = value;
                    //调用事件
                    TemperatureChangedHandler localOnChange = OnTemperatureChange;
                    if (localOnChange != null)
                    {                 
                        OnTemperatureChange(this,new TemperatureAtgs(value));//在主函数里绑定了之后，便可以调用Cooler与Heater的指定的函数了
                    }
                }

            }
        }
    }
}

定义与调用不同，其中都用注释标明了。当然，调用的时候应该把响应的订阅者的函数形式改成与事件一致，即形式如下：

  public void OnTemperatureChanged(object sender, ThermostatEvent.TemperatureAtgs newTemperature)

主函数可以不变。主要是拒绝了在包容类外的=操作与触发操作。

五、泛型事件

如果事件的第二个参数发生了改变，是不是需要另外定义一个事件呢？当然不用，微软提供了泛型委托，只要指明类型就好了。

原型定义如下：

public delegate void EventHandler<T>(object sender,T e)where T:EventArgs 

where T:EventArgs 保证了T只能继承自EventArgs 

  //声明一个委托，符合标准的参数列表
    //    public delegate void TemperatureChangedHandler(object sender, TemperatureAtgs newTemperature);
        //用事件字段封装一个事件属性
     //   public event TemperatureChangedHandler OnTemperatureChange = delegate { };//与委托不同，此处声明为了public，看似减弱封装，实际上event给了更强的限制。
        //用泛型委托
        public event EventHandler<TemperatureAtgs> OnTemperatureChange;

定义委托的两句就可以变成了一句，如上。

至于判断中的那个

 //TemperatureChangedHandler localOnChange = OnTemperatureChange;

可以注释掉，因为不存在TemperatureChangedHandler 了，其他错误提示很容易改掉，不再赘述。