发布-订阅（观察者）模式演变

（一）什么是观察者模式

发布-订阅，这两个词语是对观察者的最好解释，现实生活中，这样的案例有很多，比如在篮球比赛过程中教练，喊一个暂停，然后球员和裁判都做相关的响应，还有比如OA里面发布的放假通知等等。无论是篮球比赛，还是OA的通知，都存在一个角色，它的作用就是保持对相关问题的关注，在问题发生变化的时候，是Ta把消息通知给相关各方。观察者模式也差不多这样，它抽象一类对象（观察者）专门负责"盯着"目标对象，当目标对象状态有变动的时候，每个观察者就会获得通知并迅速做出响应，观察者模式解决的也是调用通知关系所带来的依赖。

（二）观察者模式的演变

下面请看代码。有三个类，A,B,C想接收来自X的消息，简单的说X发生变化，他们也跟着变化。

public class A {
        public int Data;
        public void Update(int data) {
            this.Data = data;
        }
    }

    public class B {
        public int Count;
        public void NotifyCount(int data) {
            this.Count = data;
        }
    }

    public class C {
        public int N;
        public void Set(int data) {
            this.N = data;
        }
    }

    //上面这三个类，类A，B，C是希望获得X通知的类型
    public class X {
        private int data;
        public A InstanceA;
        public B InstanceB;
        public C InstanceC;
        public void SetData(int data) {
            this.data = data;
            InstanceA.Update(data);
            InstanceB.NotifyCount(data);
            InstanceC.Set(data);
        }
    }   在我们调用的时候，应该这么做

A a = new A();
            B b = new B();
            C c = new C();
            X x = new X();
            x.InstanceA = a;
            x.InstanceB = b;
            x.InstanceC = c;
            x.SetData(10);
            Console.WriteLine("x发出消息了");
            Console.WriteLine(a.Data);
            Console.WriteLine(b.Count);
            Console.WriteLine(c.N);

对于上面这种做法，大家应该都会。下面是这个上面例子的类图关系，从这里，我们可以看得X和太多类直接关联了。已经很不符合面向对象的设计原则了。

经过观察，我们发现类A,B,C都有个共同之处，都是有一个类似于更新的方法，如果对他们进行抽象的话呢，就可以让类X仅仅依赖于一个抽象的类型。下面直接看代码

  public interface IUpdatableObject {
        int Data {get;}
        void Update(int newData);
    }

    public class A : IUpdatableObject {

        private int data;
        public int Data { get { return this.data; } }

        public void Update(int newData) {
            this.data = newData;
        }
    }

    public class B : IUpdatableObject {

        private int data;
        public int Data { get { return this.data; } }

        public void Update(int newData) {
            this.data = newData;
        }
    }

    public class C : IUpdatableObject {

        private int data;
        public int Data { get { return this.data; } }

        public void Update(int newData) {
            this.data = newData;
        }
    }

    public class X {
        private IUpdatableObject[] objects = new IUpdatableObject[3];

        //这个是索引器的用法
        public IUpdatableObject this[int index] { set { objects[index] = value; } }

        private int data;
        public void Update(int newData) {
            this.data = newData;
            foreach(IUpdatableObject obj in objects) {
                obj.Update(newData);
            }
        }
    }

//调用代码如下

    X x = new X();
            IUpdatableObject a = new A();
            IUpdatableObject b = new B();
            IUpdatableObject c = new C();
            x[0] = a;
            x[1] = b;
            x[2] = c;
            x.Update(10);
            Console.WriteLine("x发出了消息");
            Console.Write(a.Data);
            Console.Write(b.Data);
            Console.Write(c.Data);

通过上面我们就可以依赖于抽象了，比如当我们要新增加一个订阅者的时候，也不用去类X里面改内部代码，请看类图。

下面开始我们的版本的三；

先看看这幅图，以后我们把消息的发布者，叫做主题，接收着叫做观察者。主题类似于前文的X类，观察者类似于A,B,C类。

第二版本的时候，我们已经解决了两个对象之间的松耦合，关于观察者的一切，主题只需要知道他实现了哪个接口（前文中的IUpdatableObject接口），只要是实现了这个接口的，主题就会把他认为是观察者。

继续这观察者模式的发展和演变，到了我们第三个版本的观察者模式。到了这步，我们想到如果有观察者要退出，不订阅这个主题了，等等操作（当主题发生变化的时候，，我们应该怎么做）。根据我们的面向对象的经验，我们应该很容易想到应该把主题对象也要抽象化。

public interface ISubject {

        int Data { get; set; } //这个Data就是类似于用来发送消息的。

        /// <summary>
        /// 追加
        /// </summary>
        /// <param name="obs"></param>
        void Attach(IObserver obs);

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="obs"></param>
        void Detach(IObserver obs);
        /// <summary>
        /// 监听
        /// </summary>
        void Notify();
    }

    public interface IObserver {
        int Data { get; set; }
        void Update(int n);
    }

    public class ConcreteSubjectA : ISubject {
        public int Data { get; set; }

        public List<IObserver> ObsList = new List<IObserver>();
        public void Attach(IObserver obs) {
            Console.WriteLine("添加观察者成功");
            ObsList.Add(obs);
        }

        public void Detach(IObserver obs) {
            Console.WriteLine("删除观察者成功");
            ObsList.Remove(obs);
        }

        public void Notify() {
            foreach(var obs in ObsList) {
                obs.Update(this.Data);
            }
        }
    }
    public class ConcreteObserverA : IObserver {

        public int Data { get; set; }
        public void Update(int n) {
            this.Data = n;
        }
    }

    public class ConcreteObserverB : IObserver {
        public  int Data { get; set; }
        public void Update(int n) {
            this.Data = n;
        }
    }

    public class ConcreteObserverC : IObserver {
        public int Data { get; set; }
        public void Update(int n) {
            this.Data = n;
        }
    }

 ISubject csA = new ConcreteSubjectA();
            IObserver a = new ConcreteObserverA();
            IObserver b = new ConcreteObserverB();
            IObserver c = new ConcreteObserverC();
            csA.Attach(a);
            csA.Attach(b);
            csA.Attach(c);
            csA.Data = 20;
            //移除观察者
            csA.Detach(b);
            csA.Notify();
            //我们现在做的这个版本相对于上一个版本就是增加了对观察者的管理。
            //以及我们可以让我们的程序都是依赖于抽象。

            Console.WriteLine($"类A的数据为：{a.Data}");
            Console.WriteLine($"类B的数据为{b.Data}");
            Console.WriteLine($"类C的数据为{c.Data}");

降到这里基本上把观察者模式给讲完了，我更加喜欢叫做发布订阅模式，这样更加好理解。

我们上面的那个例子还可以在抽象一点，利用泛型类和泛型方法来做，真正的达到抽象。下面是最终版本的实现代码（把泛型类和泛型方法用上），这个大家可以思考下怎么做？相关代码暂时不贴出来先。

最后，希望大家能够带带我这个菜鸟，谢谢各位。