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

模式结构

观察者模式的好处：

   观察者模式所做的工作其实就是在解除耦合，让耦合的双方都依赖于抽象，而不是依赖于具体。从而使得各自的变化都不会影响另一边的变化。

何时使用？

1，当一个对象模型有两个方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使他们可以各自独立地改变和复用。

2，当一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变。

3，当一个对象必须通知其他对象，而它又不能假定其他对象是谁。换言之，你不希望这些对象是紧密耦合的。

示例

       在拍卖的过程中，拍卖师先说出要拍卖的商品，然后通知被邀请的前来参加拍卖会的人出价。这个过程用观察者模式来模拟，如下：

namespace 拍卖竞标
{
    //主题,通知者
    interface Subject
    {
        void Attach(Observer observer);  //增加观察者
        void Detach(Observer observer);  //减少观察者
        void Notify();  //通知

        string SubjectNotify  
        {
            get;
            set;
        }
        
    }

    //抽象观察者
    abstract class Observer
    {
        protected string name;
        protected  Subject sub;

        public Observer(string name,Subject  sub) //在构造观察者 的时候，给出一个要监听的主题
        {
            this.name=name;
            this.sub=sub;

        }

        public abstract void Update();  
    }

     //拍卖师
    class Auction : Subject
    {
        //定义一个集合，用来存放所有竞标者
        private IList<Observer> observers = new List<Observer>();

        private string auction;  //拍卖品

        //增加人
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }

        //减少人
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }

        //通知投标者可以开始出价了
        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
                
            }

        }

        //通知要拍卖的东西
        public string SubjectNotify
        {
            get { return auction; }
            set { auction = value; }
        }

        
    }

    //竞标人
    class Bidder : Observer
    {
        public Bidder (string name,Subject  sub):base( name, sub)
        {}
        public override void Update()
        {
            Console.WriteLine("现在拍卖 {0} ，投标者 {1} 可以出价了。", sub.SubjectNotify, name);
        }

 
    }


    class Program
    {
        static void Main(string[] args)
        {
            //拍卖师
            Auction paimaishi = new Auction();

            //竞拍者
            Bidder bidder1 = new Bidder("马小云", paimaishi);
            Bidder bidder2 = new Bidder("马小腾", paimaishi);

            paimaishi.Attach(bidder1);
            paimaishi.Attach(bidder2);

            //拍卖师宣布要拍卖的商品
            paimaishi.SubjectNotify = "星空（梵高）";
            paimaishi.Notify();

    
        }
    }
}
 

运行后如图：

委托和事件

     但是，拍卖师通知要拍卖的东西后，并不是每个竞拍者下一步的动作都是出价。他们可能有的要先找专家询问这幅画是不是梵高的真迹，有的要找人估算一下出多少钱才合适，有的人一直在围观。。。每个具体的观察者的动作不同，所以不能用一个Update方法来概括所有人。这时，发出通知后，产生的就是不一样的事件了，所有，在Subject中，无法用一个o.update（）方法在遍历的时候触发所有人的动作。

   这时，对发出通知后，触发不同事件这种处理，就要用到委托和事件了。（忘了点我）。

   现在，我们来对上面的程序稍作改动：

  首先，去掉抽象的观察者，定义不同的投标者，将它们收到主题后各自的反应写成不同的方法；

   然后声明委托，并在拍卖师里声明此委托的一个事件：update。

  最后，在客户端里，将不同拍卖者听到拍卖师要拍卖星空后作出的反应，也就是它们各自的方法加到拍卖师的update事件里。

这样看来，委托和事件的使用，去除了观察者模式中的遍历循环和抽象观察者，并且可以对搭载多个不同名方法，好厉害啊。。。

观察者模式（Observer Pattern）,布布扣,bubuko.com

观察者模式（Observer Pattern）

原文：http://blog.csdn.net/lhc1105/article/details/21647329