C#——观察者模式

首先了解一下委托和事件
什么是委托
委托是方法的代理，委托的是方法，当调用委托时就是调用了这个方法。
委托是一类行为的抽象。是方法的引用，是一种数据类型。
1>委托关键字 delegate :字面意思 委托，代理
生活中【中介，经纪人】
2>计算机中的委托的定义:
委托是一种数据类型，委托代表的是方法，
当调用委托时就是调用了这个方法。
方便理解：
委托是一种{声明了返回类型和参数组成的}数据类型
委托代表{表示，代理，委托}的是方法，{代表和委托签名一致的任何方法}
当调用委托时就是调用了这个方法。{委托实现对方法的间接调用}

委托签名：1.方法名 2.方法名+参数组成 3.方法名+参数组成+返回类型

委托的优点：
（1）压缩方法的调用。
（2）合理有效地使用委托能提升应用程序的性能。
（3）用于调用匿名方法。

什么是事件

生活中，我们经常会说哪里发生了某件事，然后可能会针对这件事采取的措施。例如，你的好友过生日，你需要送礼物，结婚，你需要送红包。在C＃中，过生日和结婚被当做事件来对待，而送礼和送红包是对事件作出的响应。
事件涉及两类角色－事件发布者和事件订阅者。当发生一个事件的时候，事件发布者会发布事件，事件订阅者会接收事件已发生的通知，并且做出相应的处理。其中，触发事件的对象称之为事件发布者，捕获事件且对其做出处理的称之为事件订阅者。在上述例子中，好友充当了发布者，自己则充当了事件订阅者。

Observer设计模式是为了定义对象间的一种一对多的依赖关系，以便于当一个对象的状态改变时，其他依赖于它的对象会被自动告知并更新。Observer模式是一种松耦合的设计模式。

事件定义的结构为：
访问修饰符 event 委托类型 事件名
访问修饰符一般定义为public,因为事件的订阅者需要对事件进行订阅与取消操作。定义为公共类型可以对其他类可见。事件定义还包含委托类型，它可以是自定义的委托类型

触发事件{调用事件}：事件在类内部触发,触发代码同委托调用

声明一个事件不过类似于声明一个进行了封装的委托类型的变量而已。

什么是观察者模式？
观察者模式，有时被称作发布/订阅模式，观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

结构图如下

代码如下：
定义一个抽象类（主题对象的基类），定义委托和事件还有调用事件的方法

public abstract class ModelBase
    {
        //定义委托
        public delegate void SubEventHandler();
        //定义事件
        public event SubEventHandler SubEvent;
        //调用事件的方法
        protected void Notifty()
        {
            if (this.SubEvent!=null)
            {
                //调用事件
                this.SubEvent();
            }
        }
    }

因为事件不能在其他类调用，所以这里用一个方法包裹，调用这个方法就是调用了事件
新建一个订阅者的基类

//第一种给事件添加方法的类
    public abstract class Observer
    {
                       //事件委托类 的类型
        public Observer(ModelBase childModel)
        {
            //只要当前类的子类被实例化，Response方法就会被添加进事件中
            //给事件注册方法
            childModel.SubEvent += new ModelBase.SubEventHandler(Response);
        }
        //要注册进事件的方法
        public abstract void Response();
    }

上边是给事件注册一个方法，道理同上，下边写一个给事件添加两个方法的订阅者基类

public abstract class Observer2
    {
        public Observer2(ModelBase childMode)
        {
            childMode.SubEvent += new ModelBase.SubEventHandler(Response1);
            childMode.SubEvent += new ModelBase.SubEventHandler(Response2);
        }
        public abstract void Response1();
        public abstract void Response2();
    }

主题基类和订阅者基类都定义完了，下面开始定义具体的主题对象类和具体订阅者类
主题对象类

//猫类
    public class Cat : ModelBase
    {
        //此方法用来开启事件
        public void Cry()
        {
            Console.WriteLine("猫大叫");
            this.Notifty();
        }
    }

订阅者对象类

//老鼠类
    public class Mouse : Observer
    {
        //订阅者名字
        private string name;
        //构造函数
        public Mouse(string name,ModelBase childMode):base(childMode)
        {
            this.name = name;
        }
        //因为继承Observer，当此类进行实例化的时候这个方法会自动添加进Observer类里的childMode类的事件里
        public override void Response()
        {
            Console.WriteLine(name+"赶快逃");
        }
    }

//主人类
    public class Master : Observer
    {
        private string name;
        public Master(string name,ModelBase childModel):base(childModel)
        {
            this.name = name;
        }
        public override void Response()
        {
            Console.WriteLine(name+"醒了");
        }
    }

//宝宝类
    public class Baby : Observer2
    {
        private string name;
        public Baby(string name,ModelBase childModel) : base(childModel)
        {
            this.name = name;
        }
        public override void Response1()
        {
            Console.WriteLine(name+"醒了");
        }

        public override void Response2()
        {
            Console.WriteLine(name+"开始哭了");
        }
    }

最后主函数调用

 static void Main(string[] args)
        {
            Cat cat = new Cat();
            Observer mouse = new Mouse("老鼠", cat);
            Observer master = new Master("主人", cat);
            Observer2 baby = new Baby("宝宝", cat);
            cat.Cry();
            Console.ReadKey();
        }

输出结果为
猫大叫
老鼠赶快逃
主人醒了
宝宝醒了
宝宝开始哭了