C#基础 - 事件

C#中，事件属于成员变量与private int _name;、属性等同级。
事件基于委托，为委托提供了一种发布/订阅机制，广泛用于架构内。
简单来讲就是在类中声明一个委托，并标记这个委托是一个事件，在另一个方法中执行这个事件。其中，触发这个事件的类称为发布者，接受或者注册了处理方法的类称为订阅者。
声明一个事件有两种方式，一种是自己先定义一个委托，然后用这个委托定义事件 ，另一种是直接使用泛型EventHandler。
作为约定，事件一般使用带俩个参数的方法，其中第一个参数是一个对象，包含事件的发送者，第二个参数提供了事件的相关信息。

自定义

class CarInfoEvent:EventArgs
{
}

//定义一个委托类型 NewCarHandlerDelegate，约定为void返回类型，两个参数
delegate void NewCarHandlerDelegate(object sender, CarInfoEvent e); 
class EventDemo
{
	//长记法,添加add/remove访问器
	//类似于自动属性和完整属性之间的关系，在需要处理其他逻辑时很有用
	private event NewCarHandlerDelegate _newCarInfo;
	public event NewCarHandlerDelegate NewCarInfo
	{
		add { _newCarInfo += value; }
		remove { _newCarInfo -= value; }
	}
	//以上长记法等价于
	public event NewCarHandlerDelegate NewCarInfo;
}

一般事件的定义约定俗称是一个***void方法***，第一个参数是sender表示事件的发布者，默认为object类型，第二个参数是EventArgs类型的事件变量，表示触发事件时需要订阅者注意的内容，一般用来传一些参数。
注意：生产环境中约定第一个参数叫sender，第二个参数叫e。

使用EventHandler

.net提供了泛型委托EventHandler避免大量定义委托。其定义了一个处理程序，返回void，接受两个参数，其中第一个参数为object类型，第二个为T类型。T的约束条件为：必须自基类EventArgs派生。
EventHandler定义如下：

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

事件定义：

public class EventDemo
{
	//简化记法
	//以下写法编译器会自动创建一个EventHandler<CarInfoEvent>委托类型的变量，并添加方法，以便从
    //委托中订阅和取消订阅。
    public event EventHandler<CarInfoEventArgs> NewCarInfo;
    
    //等价于长记法
    private event EventHandler<CarInfoEventArgs> _newCarInfo;
	public event EventHandler<CarInfoEvent> NewCarInfo
    {
        add { _newCarInfo += value; }
        remove { _newCarInfo -= value; }
    }
}

使用：

EventDemo demo = new EventDemo();
demo.NewCarInfo +=(sender, eventArgs) =>
{
    //省略订阅者的方法内容
}
demo.Trigger();//触发事件        

应用：观察者模式

场景：
假设我们有个海尔热水器，我们给它通上电，当水温超过95度的时候：
1、天网扬声器会开始发出语音，告诉你水的温度；
2、京东方液晶屏也会改变水温的显示，来提示水已经快烧开了。

我们定义一个类来代表热水器，我们管它叫：Heater，它有代表水温的成员变量，叫做temperature，有名字；当然，还有必不可少的给水加热方法BoilWater()，一个发出语音警报的方法MakeAlert()，一个显示水温的方法，ShowMsg()。

public class Heater
{
        public string Name { get; set; }//名字
        private int temperature; // 水温
        public Heater(string name)
        {
            Name = name;
        }

        // 烧水
        public void BoilWater()
        {
            Console.WriteLine("{0}：我开始烧水了！", Name);
            for (int i = 93; i <= 100; i++)
            {
                temperature = i;
                if (temperature > 95)
                {
                    
                }
            }
        }
        
    	// 发出语音警报
    	private void MakeAlert(int param) 
    	{
       		Console.WriteLine("Alarm：嘀嘀嘀，水已经 {0} 度了：" , param);
    	}
    
    	// 显示水温
    	private void ShowMsg(int param) 
    	{
       		Console.WriteLine("Display：水快开了，当前温度：{0}度。" , param);
    	}
}

class Program 
{
    static void Main() 
    {
       Heater ht = new Heater();
       ht.BoilWater();
    }
}

面的例子显然能完成我们之前描述的工作，但是却并不够好。现在假设热水器由三部分组成：热水器、警报器、显示器，它们来自于不同厂商并进行了组装。他们应该各做各的事，那么，应该是热水器仅仅负责烧水，它不能发出警报也不能显示水温；在水烧开时由警报器发出警报、显示器显示提示和水温。

这里就出现了一个问题：如何在水烧开的时候通知报警器和显示器？

Observer设计模式介绍：

Observer设计模式中主要包括如下两类对象：

Subject：监视对象，它往往包含着其他对象所感兴趣的内容。在本例中，热水器就是一个监视对象，它包含的其他对象所感兴趣的内容，就是temprature字段，当这个字段的值快到100时，会不断把数据发给监视它的对象。
Observer：监视者，它监视Subject，当Subject中的某件事发生的时候，会告知Observer，而Observer则会采取相应的行动。在本范例中，Observer有警报器和显示器，它们采取的行动分别是发出警报和显示水温。

在本例中，事情发生的顺序应该是这样的：
警报器和显示器告诉热水器，它对它的温度比较感兴趣(注册)。
热水器知道后保留对警报器和显示器的引用。
热水器进行烧水这一动作，当水温超过95度时，通过对警报器和显示器的引用，自动调用警报器的MakeAlert()方法、显示器的ShowMsg()方法。

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

利用事件实现该模式如下：

    public class HeaterEventArgs : EventArgs
    {
        private int temperature;
        public int Temperature
        {
            get { return temperature; }
            set { temperature = value; }
        }

        public HeaterEventArgs(int t)
        {
            temperature = t;
        }
    }

    public class Heater
    {
        public string Name { get; set; }

        private int temperature; // 水温

        public delegate void BoilWaterHandler(object sender, HeaterEventArgs e);
        public event BoilWaterHandler BoilWaterEvent;

        public Heater(string name)
        {
            Name = name;
        }

        // 烧水
        public void BoilWater()
        {
            Console.WriteLine("{0}：我开始烧水了！", Name);
            for (int i = 93; i <= 100; i++)
            {
                temperature = i;
                Thread.Sleep(1500);
                if (temperature > 95)
                {
                    BoilWaterEvent?.Invoke(this, new HeaterEventArgs(temperature));
                }
            }
        }
    }

    // 警报器
    public class Alarm
    {
        public string Name { get; set; }

        public Alarm(string name)
        {
            Name = name;
        }

        public void MakeAlert(object sender, HeaterEventArgs e)
        {
            if (e.Temperature < 100)
            {
                Console.WriteLine("{0}：嘀嘀嘀，水已经 {1} 度了：", Name, e.Temperature);
            }
           else
            {
                Console.WriteLine("{0}：呜呜呜，水已经 {1} 度了：", Name, e.Temperature);
            }
        }

    }

    // 显示器
    public class Display
    {
        public static string Name { get; set; }

        static Display()
        {
            Name = "京东方";
        }

        public static void ShowMsg(object sender, HeaterEventArgs e)
        { 
            //静态方法
            Console.WriteLine("{0}：水快烧开了，当前温度：{1}度。",Name, e.Temperature);
        }

    }

    public class ObserverDemo
    {
        public static void Run()
        {
            Heater heater = new Heater("海尔");
            Alarm alarm = new Alarm("嘟嘟");


            //警报器天网告诉热水器我对你的温度感兴趣，所以我向你注册,监视你烧水的温度
            heater.BoilWaterEvent += alarm.MakeAlert;

            //双警报器
            heater.BoilWaterEvent += new Alarm("嘀嘀").MakeAlert;


            //显示器告诉热水器我也对你的温度感兴趣，所以我向你注册,监视你烧水的温度
            heater.BoilWaterEvent += Display.ShowMsg;

            //开始烧水
            heater.BoilWater();
        }
    }