设计模式之行为模式：观察者（Observer)

意图：

• 定义对象中的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新

                                                                                                                                                                 ——《设计模式》GOF

适用性

• 当一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
• 当对一个对象的改变需要同时改变其它对象，而不知道具体有多少对象有待改变。
• 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。

结构

参与者

• Subject

1. 目标知道它的观察者。可以有任意多个观察者观察同一个目标。
2. 提供注册和删除观察者对象的接口

• Observer

1. 为那些在目标发生改变时需获得通知的对象定义一个更新接口

• ConcreteSubject

1. 将有关状态存入各Concrete Observer对象。
2. 当它的状态发生改变时，向它的各个观察者发出通知。

• ConcreteObserver

1. 维护一个指向ConcreteSubject对象的引用。
2. 存储有关状态，这些状态应与目标的状态保持一致。
3. 实现Observer的更新接口以使自身状态与目标的状态保持一致。

协作

• 当ConcreteSubject发生任何可能导致其观察者与本身状体不一致的改变时，它将通知它的各个观察者。
• 在得到一个具体目标的改变通知后，ConcreteObserver对象可向目标对象查询信息。ConcreteObserver使用这些信息以使它的状态与目标对象保持一致。

效果

1. 目标与观察者间的抽象耦合
2. 支持广播通信
3. 意外的更新

实现

1. 创建目标到其观察者的映射
2. 观察多个目标
3. 谁触发更新
4. 对已删除目标的悬挂调用
5. 在发出通知前确保目标的状态本身是一致的。
6. 避免特定与观察者的更新协议（推/拉模型）
7. 显示地指定感兴趣的改变
8. 封装复杂的更新语义
9. 结合目标类和观察者类

代码实现

    class ObserverStructure
    {
        public void Test()
        {
            Observer coa = new ConreteObserverA();
            Observer cob = new ConreteObserverB();
            Observer coc = new ConreteObserverC();
            Subject cs = new ConcreteSubject();

            cs.Attach(coa);
            cs.Attach(cob);
            cs.Attach(coc);
            cs.Notify(5);
        }
    }

    abstract class Observer
    {
        public abstract void Update(int value);
    }
    class ConreteObserverA:Observer
    {
        public override void Update(int value)
        {
            Console.WriteLine(this.GetType().Name+" 2 * value = "+(2 * value) );
        }
    }
    class ConreteObserverB : Observer
    {
        public override void Update(int value)
        {
            Console.WriteLine(this.GetType().Name + " 2 + value = " + (2 + value));
        }
    }
    class ConreteObserverC : Observer
    {
        public override void Update(int value)
        {
            Console.WriteLine(this.GetType().Name + " 2 / value = " + (2 / value));
        }
    }

    abstract class Subject
    {
        protected List<Observer> list = new List<Observer>();

        public void Attach(Observer observer)
        {
            list.Add(observer);
        }

        public void Dettach(Observer observer)
        {
            list.Remove(observer);
        }

        public void Notify(int value)
        {
            foreach (var observer in list)
            {
                observer.Update(value);
            }
        }
    }

    class ConcreteSubject : Subject {
      
    }