设计模式学习笔记观察者模式

概述：                                                                                                        

观察者模式(Oberserver)：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

实用性：                                                                                                     

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

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

3.当一个对象必须通知其他对象，而又不能假定其他对象是谁。

类图：                                                                                                         

代码示例：                                                                                                   

1.定义抽象通知者

    /// <summary>
    /// 抽象通知者，用抽象类或者借口实现。把所有对观察者对象的引用保存在一个聚集里
    /// 每个通知者都可以有任何熟练的观察者，抽象通知者提供一个接口，可以增加和删除,通知观察者对象，
    /// </summary>
    abstract class Subject
    {
        private IList<Observer> observers = new List<Observer>();

        //增加观察者
        public void Attach(Observer observer) 
        {
            observers.Add(observer);
        }
        //移除观察者
        public void Dettach(Observer observer)
        {
            observers.Remove(observer);
        }
        //通知
        public void Notify()
        { 
           foreach(Observer o in observers)
           {
               o.Update();
           }
        }
    }

2.定义抽象观察者

    /// <summary>
    /// 抽象观察者，为所有的具体观察者定义一个接口，
    /// 得到通知者的通知时更新自己，这个接口叫做更新接口
    /// 抽象观察者一般用一个抽象类或者一个接口实现，更新接口一般包含一个Update方法，
    /// </summary>
    abstract class Observer
    {
        public abstract void Update();
    }

3.定义具体观察者

    /// <summary>
    /// 具体的通知者，将有关状态存入具体观察者对象，在具体通知者的
    /// 内部状态改变时，给所有登记过的观察者发出通知
    /// </summary>
    class ConcreteSubject:Subject
    {
        /// <summary>
        /// 具体观察者状态
        /// </summary>
        private string subjectState;

        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
    }

4.定义具体通知者

    /// <summary>
    /// 具体观察者，实现抽象观察者的更新接口，以便本身的状态与通知者的状态保持
    /// </summary>
    class ConcreteObserver:Observer
    {
        private string name;
        private string observerState;
        private ConcreteSubject subject;

        public  ConcreteObserver(ConcreteSubject subject,string name) 
        {
            this.subject = subject;
            this.name = name;
        }
        public override void Update()
        {
            observerState =subject.SubjectState;
            Console.WriteLine("观察者{0}的新状态是{1}",name,observerState);
        }
        public ConcreteSubject Subject 
        {
            get { return subject; }
            set { subject = value; }
        }
    }

5.客户端调用

        /// <summary>
        /// 测试观察者模式
        /// </summary>
        static void TestObserver() 
        {
            ConcreteSubject s = new ConcreteSubject();
            s.Attach(new ConcreteObserver(s,"X"));
            s.Attach(new ConcreteObserver(s, "Y"));
            s.Attach(new ConcreteObserver(s,"Z"));

            s.SubjectState = "ABC";
            s.Notify();
            Console.Read();
        }

小结：                                                                                                         

观察者模式确实看得有点蛋疼，迷糊，不知道大家有没有这感觉,其实和委托的概念类似，应用的场合在GUI应用上比较多，还有类似的订阅服务，产品的降价通知客户也可以考虑，但是我们都可以通过委托来更好的实现，如果找到合适的应用例子再贴上来吧