事件

1. 事件由来

       上面的三个方法都定义在Programe类中，这样做是为了理解的方便，实际应用中，通常都是 GreetPeople 在一个类中，ChineseGreeting和 EnglishGreeting 在另外的类中。现在你已经对委托有了初步了解，是时候对上面的例子做个改进了。假设我们将GreetingPeople()放在一个叫GreetingManager的类中，那么新程序应该是这个样子的：

namespace Delegate {
    //定义委托，它定义了可以代表的方法的类型
    public delegate void GreetingDelegate(string name);
    
    //新建的GreetingManager类
    public class GreetingManager{
       public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
           MakeGreeting(name);
       }
    }

    class Program {
       private static void EnglishGreeting(string name) {
           Console.WriteLine("Morning, " + name);
       }

       private static void ChineseGreeting(string name) {
           Console.WriteLine("早上好, " + name);
       }

       static void Main(string[] args) {
           // ... ...
        }
    }
}

static void Main(string[] args) {
    GreetingManager gm = new  GreetingManager();
    gm.GreetPeople("Jimmy Zhang", EnglishGreeting);
    gm.GreetPeople("张子阳", ChineseGreeting);
}

这样，如果我们将多个方法绑定到同一个委托：

static void Main(string[] args) {
    GreetingManager gm = new  GreetingManager();
    GreetingDelegate delegate1;
    delegate1 = EnglishGreeting;
    delegate1 += ChineseGreeting;

    gm.GreetPeople("Jimmy Zhang", delegate1);
}

面向对象设计，讲究的是对象的封装，既然可以声明委托类型的变量(在上例中是delegate1)，我们何不将这个变量封装到 GreetManager类中？在这个类的客户端中使用不是更方便么？于是，我们改写GreetManager类，像这样：

public class GreetingManager{
    //在GreetingManager类的内部声明delegate1变量
    public GreetingDelegate delegate1;  

    public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
       MakeGreeting(name);
    }
}

在调用gm.GreetPeople方法的时候，再次传递了gm的delegate1字段：

gm.GreetPeople("Jimmy Zhang", gm.delegate1);

既然这样，可以修改GreetingManager类：

public class GreetingManager{
    //在GreetingManager类的内部声明delegate1变量
    public GreetingDelegate delegate1;  

    public void GreetPeople(string name) {
        if(delegate1!=null){     //如果有方法注册委托变量
          delegate1(name);      //通过委托调用方法
       }
    }
}

客户端调用就会简洁不少：

static void Main(string[] args) {
    GreetingManager gm = new  GreetingManager();
    gm.delegate1 = EnglishGreeting;
    gm.delegate1 += ChineseGreeting;

    gm.GreetPeople("Jimmy Zhang");      //注意，这次不需要再传递 delegate1变量
}

尽管这样达到了我们要的效果，但是还是存在着问题：

在这里，delegate1和我们平时用的string类型的变量没有什么分别，而我们知道，并不是所有的字段都应该声明成public，合适的做法是应该public的时候public，应该private的时候private。

我们先看看如果把 delegate1 声明为 private会怎样？结果就是：这简直就是在搞笑。因为声明委托的目的就是为了把它暴露在类的客户端进行方法的注册，你把它声明为private了，客户端对它根本就不可见，那它还有什么用？

再看看把delegate1 声明为 public 会怎样？结果就是：在客户端可以对它进行随意的赋值等操作，严重破坏对象的封装性。

最后，第一个方法注册用“=”，是赋值语法，因为要进行实例化，第二个方法注册则用的是“+=”。但是，不管是赋值还是注册，都是将方法绑定到委托上，除了调用时先后顺序不同，再没有任何的分别，这样不是让人觉得很别扭么？

现在我们想想，如果delegate1不是一个委托类型，而是一个string类型，你会怎么做？答案是使用属性对字段进行封装。

于是，Event出场了，它封装了委托类型的变量，使得：在类的内部，不管你声明它是public还是protected，它总是private的。在类的外部，注册“+=”和注销“-=”的访问限定符与你在声明事件时使用的访问符相同。

这样可以用事件代替委托变量：

public class GreetingManager{
    //这一次我们在这里声明一个事件
    public event GreetingDelegate MakeGreet;

    public void GreetPeople(string name) {
        MakeGreet(name);
    }
}
static void Main(string[] args) {
    GreetingManager gm = new  GreetingManager();
    gm.MakeGreet = EnglishGreeting;         // 编译错误1
    gm.MakeGreet += ChineseGreeting;

    gm.GreetPeople("Jimmy Zhang");
}

对照前文区别在于就是多个event ，其余完全一致！！！！

2. Observer设计模式简介

      两个组成部分，监视者和被监视者，被监视者存在监视者感兴趣的东西，当感兴趣的东西，监视者就会触发相应信号来响应，即监视者就得做出反应。

例如热水器的例子：包括烧水器、警报器、显示器。警报器、显示器就是监视者对烧水器温度感兴趣，温度发生变化就会显示出来，以及温度达到设定值就会报警。

namespace Heater
{
    public class Heater
    {
        int temperture;
        public delegate void BoliHandler(int param);
        public BoliHandler BoilEvent;
        public void BoilWater()
        {
            for(int i = 0;i<=100;i++)
            {
                temperture = i;
                if(temperture>95)
                {
                    if(BoilEvent != null)
                    {
                        BoilEvent(i);
                    }
                }
            }
        }

    }

    public class Display
    {
        /// <summary>
        /// 显示温度
        /// </summary>
        public void displayTemp(int temp)
        {
            Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：", temp);
        }
    }

    public class Alarm
    {
        /// <summary>
        /// 报警
        /// </summary>
        /// <param name="temp"></param>
        public void alarmInfo(int temp)
        {
            Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", temp);

        }
    }
}
    class Program
    {
        static void Main(string[] args)
        {
            Heater heater = new Heater();
            Display display = new Display();
            Alarm alarm = new Alarm();
            heater.BoilEvent += new Heater.BoliHandler(display.displayTemp);
            heater.BoilEvent += alarm.alarmInfo;

            heater.BoilWater();

            Console.ReadKey();

        }
    }

如果不想给客户端随意使用displayTemp，alarm.alarmInfo，保护封装性，那们可以在监视者构造函数中注册方法：

namespace Heater
{
    public class Heater
    {
        int temperture;
        public delegate void BoliHandler(int param);
        public BoliHandler BoilEvent;
        public void BoilWater()
        {
            for(int i = 0;i<=100;i++)
            {
                temperture = i;
                if(temperture>95)
                {
                    if(BoilEvent != null)
                    {
                        BoilEvent(i);
                    }
                }
            }
        }

    }

    public class Display
    {
        Heater heater;
        public Display(Heater _heater)
        {
            heater = _heater;
            heater.BoilEvent += new Heater.BoliHandler(displayTemp);
        }
        /// <summary>
        /// 显示温度
        /// </summary>
        private void displayTemp(int temp)
        {
            Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：", temp);
        }
    }

    public class Alarm
    {
        Heater heater;

        public Alarm(Heater _heater)
        {
            heater = _heater;
            heater.BoilEvent += new Heater.BoliHandler(alarmInfo);
        }
        /// <summary>
        /// 报警
        /// </summary>
        /// <param name="temp"></param>
        private void alarmInfo(int temp)
        {
            Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", temp);

        }
    }
}

            Heater heater = new Heater();
            Display display = new Display(heater);
            Alarm alarm = new Alarm(heater);
          ///  heater.BoilEvent += new Heater.BoliHandler(display.displayTemp);
           // heater.BoilEvent += alarm.alarmInfo;

            heater.BoilWater();

            Console.ReadKey();

这样就可以完全隐藏一些方法了。

3. .Net FrameWork 中委托与事件

尽管上面的范例很好地完成了我们想要完成的工作，但是我们不仅疑惑：为什么.Net Framework 中的事件模型和上面的不同？为什么有很多的EventArgs参数？

在回答上面的问题之前，我们先搞懂 .Net Framework的编码规范：

• 委托类型的名称都应该以EventHandler结束。
• 委托的原型定义：有一个void返回值，并接受两个输入参数：一个Object 类型，一个 EventArgs类型(或继承自EventArgs)。
• 事件的命名为 委托去掉 EventHandler之后剩余的部分。
• 继承自EventArgs的类型应该以EventArgs结尾。

再做一下说明：

1. 委托声明原型中的Object类型的参数代表了Subject，也就是监视对象，在本例中是 Heater(热水器)。回调函数(比如Alarm的MakeAlert)可以通过它访问触发事件的对象(Heater)。
2. EventArgs 对象包含了Observer所感兴趣的数据，在本例中是temperature。

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

现在我们改写之前的范例，让它符合 .Net Framework 的规范：

namespace Heater
{
    public class Heater
    {
        int temperture;
        // public delegate void BoliHandler(int param);
        public delegate void BoliEventHandler(object sender, BoiledEventArgs e);
        public BoliEventHandler BoilEvent;

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

        protected virtual void OnBoiled(BoiledEventArgs e)
        {
            if (BoilEvent != null)
            {
                BoilEvent(this, e);
            }
        }

        public void BoilWater()
        {
            for(int i = 0;i<=100;i++)
            {
                temperture = i;
                if(temperture>95)
                {
                    BoiledEventArgs e = new BoiledEventArgs(i);
                    OnBoiled(e);
                }
            }
        }

    }

    public class Display
    {
        Heater heater;
        public Display(Heater _heater)
        {
            heater = _heater;
            heater.BoilEvent += new Heater.BoliEventHandler(displayTemp);
        }
        /// <summary>
        /// 显示温度
        /// </summary>
        private void displayTemp(object sender, Heater.BoiledEventArgs temp)
        {
            Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：", temp.temperature);
        }
    }

    public class Alarm
    {
        Heater heater;

        public Alarm(Heater _heater)
        {
            heater = _heater;
            heater.BoilEvent += new Heater.BoliEventHandler(alarmInfo);
        }
        /// <summary>
        /// 报警
        /// </summary>
        /// <param name="temp"></param>
        private void alarmInfo(object sender,Heater.BoiledEventArgs temp)
        {
            Console.WriteLine("Display：水快烧开了，当前温度：{0}度。", temp.temperature);

        }
    }
}


        static void Main(string[] args)
        {
            Heater heater = new Heater();
            Display display = new Display(heater);
            Alarm alarm = new Alarm(heater);
          ///  heater.BoilEvent += new Heater.BoliHandler(display.displayTemp);
           // heater.BoilEvent += alarm.alarmInfo;

            heater.BoilWater();

            Console.ReadKey();

        }