观察者模式（12）

今天我们来讲一下观察者模式。还是老样子，给大家一个案例。

一、案例

在我们怀念的学生时代，我们会有这么一个现象，当在教室里上自习的时候，让一个同学把风，我们在教室里玩，当老师来的时候，让那个同学给我们说一声。

好，下面我们就用简单的控制台应用程序来实现上述的场景（一个把风的同学，两个玩耍的同学）

    /// <summary>
    /// 把风同学类
    /// </summary>
    class Secretary
    {
        //有几个同学请把风的帮忙，于是就给集合增加几个对象
        private IList<Observer> obs = new List<Observer>();
        private string _action;

        public void Attach(Observer ob)
        {
            obs.Add(ob);
        }

        /// <summary>
        /// 老师回来时，给所有登记的同学们发通知。
        /// </summary>
        public void Notify()
        {
            foreach (var ob in obs)
            {
                ob.Update();
            }
        }
        /// <summary>
        /// 状态
        /// </summary>
        public string SecretoryAction
        {
            get { return _action; }
            set { _action = value; }
        }
    }

    /// <summary>
    /// 玩耍的同学类
    /// </summary>
    class Observer
    {
        private string name;
        private Secretary sub;

        public Observer(string name, Secretary sub)
        {
            this.name = name;
            this.sub = sub;
        }
        /// <summary>
        /// 得到把风的通知
        /// </summary>
        public void Update()
        {
            Console.WriteLine($"{sub.SecretoryAction}{name}别玩游戏了");
        }
    }

客户端：

        public static void Main()
        {
            //把风的
            Secretary s = new Secretary();
            //小王同学
            Observer ob1 = new Observer("小王", s);
            //小李同学
            Observer ob2 = new Observer("小李", s);
            //把风的记下两位同学
            s.Attach(ob1);
            s.Attach(ob2);
            //发现老师来了
            s.SecretoryAction = "老师回来了！";
            //通知两个同学
            s.Notify();
            Console.ReadKey();
        }

嗯，上述代码我们发现了一个问题，就是 把风的这个同学的类 和 玩耍的同学的类，耦合性太强了。把风类需要增加玩耍的同学，同学类需要把风的通知。

这么强的耦合，如果我们需要添加一个同学进来，那两边都需要修改了，如果还要通知唱歌同学老师来了，咋办？这其实违背了设计的两个原则，开放-封闭原则，依赖倒转原则。

我们的程序都应该依赖于抽象，而不是相互依赖。

二、演绎

1、第一步演绎

好，下面我们来修改一下上述的代码。增加一个抽象的观察者类

    /// <summary>
    /// 抽象的观察者
    /// </summary>
    public abstract class Observer
    {
        protected string name;
        protected Secretary sub;

        public Observer(string name, Secretary sub)
        {
            this.name = name;
            this.sub = sub;
        }

        public abstract void Update();
    }

让具体的观察者继承这个抽象类

    /// <summary>
    /// 具体的观察者1（玩游戏的）
    /// </summary>
    public class Observer1 : Observer
    {
        public Observer1(string name, Secretary sub) : base(name, sub)
        {
        }

        public override void Update()
        {
            Console.WriteLine($"{sub.SecretoryAction}{name},别唱歌了。");
        }
    }
    /// <summary>
    /// 具体的观察者2（唱歌的）
    /// </summary>
    public class Observer2 : Observer
    {
        public Observer2(string name, Secretary sub) : base(name, sub)
        {
        }

        public override void Update()
        {
            Console.WriteLine($"{sub.SecretoryAction}{name},别玩游戏了。");
        }
    }

把风同学类的代码基本不变

    /// <summary>
    /// 把风同学类
    /// </summary>
    public class Secretary
    {
        //有几个同学请把风的帮忙，于是就给集合增加几个对象
        private IList<Observer> obs = new List<Observer>();
        private string _action;

        public void Attach(Observer ob)
        {
            obs.Add(ob);
        }

        /// <summary>
        /// 老师回来时，给所有登记的同学们发通知。
        /// </summary>
        public void Notify()
        {
            foreach (var ob in obs)
            {
                ob.Update();
            }
        }
        /// <summary>
        /// 状态
        /// </summary>
        public string SecretoryAction
        {
            get { return _action; }
            set { _action = value; }
        }
    }

客户端调用

        public static void Main()
        {
            //把风的
            Secretary s = new Secretary();
            //玩耍小王同学
            Observer ob1 = new Observer1("小王", s);
            //玩耍小李同学
            Observer ob2 = new Observer1("小李", s);
            //玩耍小李同学
            Observer ob3 = new Observer2("小张", s);
            //把风的记下三位同学
            s.Attach(ob1);
            s.Attach(ob2);
            s.Attach(ob3);
            //发现老师来了
            s.SecretoryAction = "老师回来了！";
            //通知三位同学
            s.Notify();
            Console.ReadKey();
        }

2、第二步演绎

既然观察者我们抽象出一个抽象类来了，那么我们仔细观察一下，把风的同学这个类是一个具体的类，也可以抽象出来。还有，如果哪个同学跟把风的那个同学闹矛盾了，可以不给他通知了，嘿嘿。所以可以加一个删除方法。好了，看一下代码吧

    /// <summary>
    /// 把风类抽象出来的接口
    /// </summary>
    interface Subject
    {
        void Attach(Observer ob);
        void Detach(Observer ob);

        string SecretoryAction
        {
            get;
            set;
        }
    }

具体的把风同学的类可继承这个接口

    /// <summary>
    /// 把风同学类
    /// </summary>
    public class Secretary : Subject
    {
        private IList<Observer> obs = new List<Observer>();
        private string action;
        public void Attach(Observer ob)
        {
            obs.Add(ob);
        }

        public void Detach(Observer ob)
        {
            obs.Remove(ob);
        }

        public void Notify()
        {
            foreach (var o in obs)
            {
                o.Update();
            }
        }
        public string SecretoryAction
        {
            get { return action; }
            set { action = value; }
        }
    }

客户端：

        public static void Main()
        {
            //把风的
            Secretary s = new Secretary();
            //玩耍小王同学
            Observer ob1 = new Observer1("小王", s);
            //玩耍小李同学
            Observer ob2 = new Observer1("小李", s);
            //玩耍小李同学
            Observer ob3 = new Observer2("小张", s);
            //把风的记下三位同学
            s.Attach(ob1);
            s.Attach(ob2);
            s.Attach(ob3);
            //发现老师来了
            s.SecretoryAction = "老师回来了！";
            //通知三位同学
            s.Notify();
            Console.ReadKey();
        }

ok，观察者模式就讲完了，下面我们来总结一下：

观察者模式：又叫 发布-订阅模式，他定义了一种一对多的依赖关系，让多个观察者对象共同监听同一个主题对象，当主题对象状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

观察者模式所做的事情就是解耦，让耦合的双方都依赖于抽象，而不依赖于具体，从而使得自己的变化不会影响到另一边。

好了，观察者模式我么你就说到这里了，下一篇博文，将会讲 抽象工厂模式

---

本系列将持续更新，喜欢的小伙伴可以点一下关注和推荐，谢谢大家的支持。