part01.04 事件

　　1. C#事件的概念

C# 中时间允许一个对象将发生的事件通知其他对象，将发生的事件的事件源叫发行者，通知其他的对象叫订阅者，但是订阅者可以定义也可以不定义（事件发生者也可以是事件的订阅者）

class Program
    {
        static void Main(string[] args)
        {
            var user = new User();
            user.Name = "xiaohon";
            user.Password = "123";

            user.EventLogin += new User.DelegateLogin(User_EventLogin);
            user.Login();

        }

        private static void User_EventLogin()
        {
            Console.WriteLine("login seccessful");
        }
    }

    class User
    {
        public delegate void DelegateLogin();   //  定义一个委托
        public event DelegateLogin EventLogin;  //  定义一个事件（事件用关键字加委托名来定的且后面无括号）

        public string Name { get; set; }
        public string Password { get; set; }

        /// <summary>
        /// 类的方法（可做为方法的参数即委托）
        /// </summary>
        public void Login()
        {
            Console.WriteLine("Login.....");

            //  引发事件
            if (EventLogin != null)
            {
                EventLogin();
            }
        }
    }

2. 事件的声明

。事件是成员，它必须声明在类或类型中，和其他成员一样。

。由于事件不是类型，我们不能像委托那样使用对象创建表达式（new 表达式）来创建它的对象。

。事件成员被隐式自动初始化为 null 。

3. 委托类型和 EventHandler

。事件声明需要委托类型的名字，我们可以声明一个委托类型或使用已存在的。声明一个委托类型，它必须指定事件保存的方法的签名和返回类型。

。更好的方案就是使用 EventHandler 委托。

4. 触发事件

。在触发事件之前和 null 进行比较，从而查看是否包含任何事件处理程序，如果事件是 null ，则表示没有。

。出发事件本身看起来像调用函数一样。

5. 订阅事件

。使用 += 运算符来添加事件处理程序（即绑定多个方法），方法可以是：

　　。实例方法

　　。静态方法

　　。匿名方法

　　。Lambda 表达式

。使用 -= 运算符来移除事件处理程序（即删除多个方法）

6. 关于 EventArg 类

 。EventArgs 被设计为不能专递任何数据。它用于不需要传递数据的事件处理程序。

。通过扩展 EventArgs 来传递数据。

7. 观察者（Observer）设计模式的一种实现

热水器，加电烧水，当水温超过 95 度的时候：
　　1. 扬声器会开始 发出语音，告诉你水的温度；
　　2. 液晶屏也会改变水温的显示，来提示水已经快烧开了。
如何在水快烧开的时候通知报警器和显示器？

 

1. 警报器和显示器告诉热水器，它对它的温度比较感兴趣(注册)。
2. 热水器知道后保留对警报器和显示器的引用。
3. 热水器进行烧水这一动作，当水温超过 95 度时，通过对警报器和显示器的引用，自动 调用警报器的 MakeAlert()方法、显示器的 ShowMsg()方法

。Observer 设计模式：Observer 设计 模式是为了定义对象间的一种一对多的依赖关系，以便于当一个对象的状态改变时，其他依赖 于它的对象会被自动告知并更新。Observer 模式是一种松耦合的设计模式
。Observer 设计模式中主要包括如下两类对象：
　　。Subject：监视对象，它往往包含着其他对象所感兴趣的内容。在本范例中，热水器就是一个监视对象，它包含的其他对象所感兴趣的内容，就是 temperature 属性，当这个属性的值快到 100 时，会不断把数据发给监视它的对象。
　　。Observer：观察者，它监视 Subject，当 Subject 中的某件事发生的时候，会告知 Observer，而 Observer 则会采取相应的行动。在本范例中，Observer 有警报器和显示器，它们采取的行动分别是发出警报和显示水温。

常规的实现：

 class Program
    {
        static void Main(string[] args)
        {
            var heater = new Heater();  //  创建热水器对象
            var alarm = new Alarm();    //  创建报警器对象

            heater.BoilEvent += alarm.MakeAlarm;    //  注册报警方法
            heater.BoilEvent += (new Alarm()).MakeAlarm;    //  给匿名对象注册方法
            heater.BoilEvent += Display.ShowMsg;    //  注册静态方法

            heater.BoilWater();     //  开始烧水，根据方法的条件会自动调用注册的方法

            Console.ReadKey();
        }
    }

    /// <summary>
    /// 热水器
    /// </summary>
    class Heater
    {
        private int temperature;    //  温度
        public delegate void BoilHandler(int temp);     //  声明委托
        public event BoilHandler BoilEvent;     //  声明事件

        /// <summary>
        /// 烧水
        /// </summary>
        public void BoilWater()
        {
            for(int i = 95; i <= 100; i++)
            {
                temperature = i;
                if (temperature > 95)
                {
                    //  如果定义的事件有对象注册
                    if(BoilEvent != null)
                    {
                        //  则执行其中的所有方法
                        BoilEvent(temperature);
                    }
                }
            }
        }
    }

    /// <summary>
    /// 温度显示器
    /// </summary>
    class Display
    {
        /// <summary>
        /// 显示方法
        /// </summary>
        /// <param name="temp">温度</param>
        public static void ShowMsg(int temp)
        {
            Console.WriteLine("显示器：水快烧开了，当前温度是{0}度", temp);
        }
    }

    /// <summary>
    /// 报警器
    /// </summary>
    class Alarm
    {
        /// <summary>
        /// 报警方式
        /// </summary>
        /// <param name="temp">温度</param>
        public void MakeAlarm(int temp)
        {
            Console.WriteLine("当前温度是" + temp + "度");
        }
    }

8. .Net Framework 中的委托和事件

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

2. 委托的原型定义：有一个 void 返回值，并接受两个输入参数：一个 Object 类型，一个 EventArgs 类型（或继承自 EventArgs）。

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

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

5. 委托声明原型中的 Object 类型的参数代表了 Subject ，也就是监视对象，在本例中是 Heater（热水器）。回调函数（比如 Alarm 的MakeAlert）可以通过它访问触发事件的对象（Heater）。

6. EventArgs 对象包含了 Observer 所感兴趣的数据，在本例中是 temperature。

改进后的代码：

 class Program
    {
        static void Main(string[] args)
        {
            var heater = new Heater();  //  创建热水器对象
            var alarm = new Alarm();    //  创建报警器对象

            //heater.BoilEvent += alarm.MakeAlarm;    //  注册报警方法
            //heater.BoilEvent += (new Alarm()).MakeAlarm;    //  给匿名对象注册方法

            heater.Boiled += Display.ShowMsg;    //  注册静态方法
            heater.Boiled += new Heater.BoilEventHandler(alarm.MakeAlarm);  //  另一种注册方式

            heater.BoilWater();     //  开始烧水，根据方法的条件会自动调用注册的方法

            Console.ReadKey();
        }
    }

    /// <summary>
    /// 热水器
    /// </summary>
    class Heater
    {
        private int _Temperature;    //  温度
        public string Brand = "格星 X-1219";
        public string Manufacturer = "xx 格星电器有限责任公司";

        //  委托的原型定义：有一个 void 返回值，并接受两个输入参数：一个 Object 类型， 一个 EventArgs 类型（或继承自 EventArgs）
        public delegate void BoilEventHandler(object sender,BoiledEventArgs e);     //  声明委托   委托类型的名称都应该以 EventHandler 结束
        public event BoilEventHandler Boiled;     //  声明事件  事件的命名为委托去掉 EventHandler 之后剩余的部分

        /// <summary>
        /// 构建一个可以重写的方法，以便它的派生类拒绝其他对象的访问
        /// </summary>
        /// <param name="e">事件参数</param>
        protected virtual void OnBoiled(BoiledEventArgs e)
        {
            if(Boiled != null)
            {
                Boiled(this, e);
            }
        }

        /// <summary>
        /// 烧水
        /// </summary>
        public void BoilWater()
        {
            for(int i = 95; i <= 100; i++)
            {
                _Temperature = i;
                if (_Temperature > 95)
                {
                    BoiledEventArgs e = new BoiledEventArgs(_Temperature);
                    OnBoiled(e);
                }
            }
        }
    }

    /// <summary>
    /// 定义一个事件参数类，用于承载需要传递给 Observer 所感兴趣的信息
    /// 继承自 EventArgs 的类型应该以 EventArgs 结尾
    ///  EventArgs 对象包含了 Observer 所感兴趣的数据，在本例中是 _Temperature
    /// </summary>
    public class BoiledEventArgs : EventArgs
    {
        public readonly int _Temperature;

        public BoiledEventArgs(int temp)
        {
            this._Temperature = temp;
        }
    }

    /// <summary>
    /// 温度显示器
    /// </summary>
    class Display
    {
        /// <summary>
        /// 显示方法
        /// </summary>
        /// <param name="temp">温度</param>
        public static void ShowMsg(object sender,BoiledEventArgs e)
        {
            var obj = sender as Heater;
            Console.WriteLine("显示器{0}({1})", obj.Brand, obj.Manufacturer);
            Console.WriteLine("显示器：水快烧开了，当前温度是{0}度", e._Temperature);
        }
    }

    /// <summary>
    /// 报警器
    /// </summary>
    class Alarm
    {
        /// <summary>
        /// 报警方式
        /// </summary>
        /// <param name="temp">温度</param>
        public void MakeAlarm(object sender,BoiledEventArgs e)
        {
            Console.WriteLine("当前温度是" + e._Temperature + "度");
        }
    }

参考网址：https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/events/