老生常谈：观察者模式

      观察者模式别名:

         1:发布-订阅（Publish/Subscribe）模式;

         2:模型-视图（Model/View）模式;

         3:源-监听器（Source/Listener）模式;

         4:从属者（Dependents）模式。

       观察者模式定义:

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

        C#中观察者模式:

          .NET中提供了Delegate与Event机制，这是简化Observer模式。

        引用吕老师文章中的一个例子来分析。他在文中用传统的观察者模式，这里我来完成吕老师留下的问题，用事件机制来实现。

        一个实际应用观察者模式的例子：

            该例子演示了注册的投资者在股票市场发生变化时，可以自动得到通知。下面的结构图均是这个例子的类图，和标准类图有些差别。

        传统观察者模式的结构:

            1:抽象主题（Subject）角色：主题角色把所有对观察考对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，主题角色又叫做抽象被观察者（Observable）角色，一般用一个抽象类或者一个接口实现。

abstract class Stock
    {
        // Fields
        protected string symbol;
        protected double price;
        private ArrayList investors = new ArrayList();
        // Constructor
        public Stock(string symbol, double price)
        {
            this.symbol = symbol;
            this.price = price;
        }
        // Methods
        public void Attach(Investor investor)
        {
            investors.Add(investor);
        }
        public void Detach(Investor investor)
        {
            investors.Remove(investor);
        }
        public void Notify()
        {
            foreach (Investor i in investors)
                i.Update(this);
        }
        // Properties
        public double Price
        {
            get { return price; }
            set
            {
                price = value;
                Notify();
            }
        }
        public string Symbol
        {
            get { return symbol; }
            set { symbol = value; }
        }
    }

            2:抽象观察者（Observer）角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者角色一般用一个抽象类或者一个接口实现。在这个示意性的实现中，更新接口只包含一个方法（即Update()方法），这个方法叫做更新方法。 

// "Observer"
    interface IInvestor
    {
        // Methods
        void Update(Stock stock);
    }

           2:具体主题（ConcreteSubject）角色：将有关状态存入具体现察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者角色（Concrete Observable）。具体主题角色通常用一个具体子类实现。 这里的状态值在本示例中并没有体现出来，被观察者给观察者发出的行为已经转移到抽象主题类的字段中。

// "ConcreteSubject"
    class IBM : Stock
    {
        // Constructor
        public IBM(string symbol, double price)
            : base(symbol, price) { }
    }

          3:具体观察者（ConcreteObserver）角色：存储与主题的状态自恰的状态。具体现察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体现察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。

// "ConcreteObserver"
    class Investor : IInvestor
    {
        // Fields
        private string name;
        private string observerState;
        private Stock stock;
        // Constructors
        public Investor(string name)
        {
            this.name = name;
        }
        // Methods
        public void  Update(Stock stock)
        {
            Console .WriteLine ("Notified investor {0} of {1}'s change to {2:C}",
              name, stock.Symbol, stock.Price);
        }
        // Properties
        public Stock Stock
        {
            get { return stock; }
            set { stock = value; }
        }
    }

           4:客户端代码：

  // Create investors
            Investor s = new Investor("Sorros");
            Investor b = new Investor("Berkshire");
            // Create IBM stock and attach investors
            IBM ibm = new IBM("IBM", 120.00);
            ibm.Attach(s);
            ibm.Attach(b);
            // Change price, which notifies investors
            ibm.Price = 120.10;
            ibm.Price = 121.00;
            ibm.Price = 120.50;
            ibm.Price = 120.75;

          结构总结：从具体主题角色指向抽象观察者角色的合成关系，代表具体主题对象可以有任意多个对抽象观察者对象的引用。之所以使用抽象观察者而不是具体观察者，意味着主题对象不需要知道引用了哪些ConcreteObserver类型，而只知道抽象Observer类型。这就使得具体主题对象可以动态地维护一系列的对观察者对象的引用，并在需要的时候调用每一个观察者共有的Update()方法。这种做法叫做"针对抽象编程"。

        事件和委托的实现过程：

        事件机制实现的结构图：

          1：抽象主题（Subject）角色：

//Delegate
    delegate void UpdateDelegate(Stock stock);
    //Subject
    class Stock
    {
        public event UpdateDelegate UpdateHandler;

        // Methods
        public void Attach(UpdateDelegate ud)
        {
            UpdateHandler += ud;
        }
        public void Detach(UpdateDelegate ud)
        {
            UpdateHandler -= ud;
        }
        public void Notify()
        {
            if (UpdateHandler != null) UpdateHandler(this);
        }
        // Fields
        public string symbol
        {
            get;
            set;
        }
        private double _price;
        public double price
        {
            get { return this._price; }
            set 
            {
                this._price = value;
                this.Notify();
            }      
        }
        // Constructor
        public Stock(string symbol, double price)
        {
            this.symbol = symbol;
            this.price = price;
        }
    }

          2:抽象观察者（Observer）角色：在事件实现的机制中将这一部分去掉了，因为这样对观察都没有严格的限制，传统的观察都实现抽象观察者接口中的方法，而事件则没有这种限制，它允许观察者有不同的行为。

          3:具体主题（ConcreteSubject）角色：

//ConcreteSubject
    class IBM : Stock
    {
        // Constructor
        public IBM(string symbol, double price)
            : base(symbol, price) { }
    }

           4:具体观察者（ConcreteObserver）角色：

// "ConcreteObserver"
    class Investor
    {
        // Fields
        private string name;
        private string observerState;
        private Stock stock;

        // Constructors
        public Investor(string name, Stock _stock)
        {
            this.name = name;
            this.stock = _stock; 
        }

        // Methods
        public void Update(Stock stock)
        {
            Console.WriteLine("Notified investor {0} of {1}'s change to {2:C}",
              name, stock.symbol, stock.price);
        }

        // Properties
        public Stock Stock
        {
            get { return stock; }
            set { stock = value; }
        }
    }

        4：客户端代码：

IBM ibm = new IBM("IBM", 120.00);
            Investor o1 = new Investor("用户A", ibm);
            Investor o2 = new Investor("用户B", ibm);
            ibm.Attach(new UpdateDelegate(o1.Update));
            ibm.Attach(new UpdateDelegate(o2.Update));
            // Change price, which notifies investors
            ibm.price = 120.10;
            ibm.price = 121.00;
            ibm.price = 120.50;
            ibm.price = 120.75;

       观察者模式的优缺点:

           Observer模式的优点是实现了表示层和数据逻辑层的分离，并定义了稳定的更新消息传递机制，类别清晰，并抽象了更新接口，使得可以有各种各样不同的表示层（观察者）。但是其缺点是每个外观对象必须继承这个抽像出来的接口类，这样就造成了一些不方便，比如有一个别人写的外观对象，并没有继承该抽象类，或者接口不对，我们又希望不修改该类直接使用它。虽然可以再应用Adapter模式来一定程度上解决这个问题，但是会造成更加复杂烦琐的设计，增加出错几率。

      观察者模式的效果有以下几个优点：

       （1）观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体现察者聚集，每一个具体现察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。

       （2）观察者模式支持广播通信。被观察者会向所有的登记过的观察者发出通知。

      观察者模式有下面的一些缺点：

       （1）如果一个被观察者对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

       （2）如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察考模式时要特别注意这一点。

       （3）如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。

       （4）虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。

注：
   本文参考：
   《java与模式》
    http://www.cnblogs.com/zhenyulu/articles/73723.html