设计模式二十四讲之《观察者模式》

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

使用时机：1.当一个对象的改变需要同时改变其他对象的时候，而且它不知道具体有多少对象有待改变时；例如游戏中的红点系统等
2.一个抽象模型有两个方面，其中一个方面依赖于另一个方面，这时用观察者模式可以将这两者封装在独立的对象中使它们各自独立地改变和复用；

---

  class Program
    {
        static void Main(string[] args)
        {
            //ProSubject s = new ConcreteSubject();                //观察者模式原型         
            //                                                     //步骤：1.为方便拓展，抽象父类ProSubject，实现子类ConcreteSubject（公用不修改的直接在父类中实现），在调用时，取得子类对象；                                                               
            //s.Attach(new ConcreteObserver(s, "X"));              //      2.为方便拓展，抽象父类ProObserver，实现子类ConcreteObserver，在调用时，直接使用子类对象；
            //s.Attach(new ConcreteObserver(s, "Y"));              //      3.ConcreteSubject中的Attach中添加ConcreteObserver对象（此时ConcreteObserver对象的构造同时获取ConcreteSubject对象）；
            //s.Attach(new ConcreteObserver(s, "Z"));              //      4. s.SubjectState的参数修改，用于后面显示；
            //                                                     //      5. s.Notify方法调用输出结果；
            //s.SubjectState = "ABC";

            //s.Notify();
            Console.Read();




            //ISubject secretary = new Secretary();                                     //这个例子很好的体现了开闭原则
            //Observer tongShi1 = new StockObserver("小明", secretary);                 //执行步骤：1.声明ISubject对象secretary，并将其子类Secretary实例化传递给它；
            //Observer tongShi2 = new NBAObserver("小王", secretary);                   //          2.声明Observer对象tongShi1/tongShi2，并将其子类StockObserver/NBAObserver加入参数（name,ISubject）后实例化传递给它；
            //                                                                          //          3.调用ISubject的Attach方法，传入tongShi1/tongShi2对象完成“通知注册”，也就是加入到ISubject下具体子类的Observer列表中；
            //secretary.Attach(tongShi1);                                               //          4.需要取消注册是也可以调用ISubject的Detach方法取消“通知注册”，也就是将ISubject下具体子类的Observer列表中通过参数加入的元素Remove掉；
            //secretary.Attach(tongShi2);                                               //          5.修改输出ISubject的SubjectState（输出状态）的内容，用于后面的显示；
            //                                                                          //          6.调用ISubject的Notify方法（Notify方法的具体实现体现在其子类中），然后输出结果。
            //secretary.Detach(tongShi2);

            //secretary.SubjectState = "毛毛都的无聊生活，老板回来了";
            //secretary.Notify();
            //Console.Read();

            //事件委托+观察者模式事例

            //    委托是一种引用方法的类型。一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数
            //和返回值。委托可以看作是对函数的抽象，是函数的“类”，委托的实例将代表一个具体的函数。
            Boss boss = new Boss();
            StockObserver tongshi1 = new StockObserver("Legend", boss);                              //执行步骤：1.申明并实例化Boss的对象boss;
            NBAObserver tongshi2 = new NBAObserver("Mars", boss);                                    //          2.声明并实例化StockObserver/NBAObserver的对象tongshi1/tongshi2并传入参数（name,Boss）;
            //                                                                                       //          3.调用Boss中的Update委托进行委托，实例化EventHandler委托并将StockObserver中的CloseStockMarket/NBAObserver中的CloseNBADirecteSeeding方法作为参数传入，
            boss.Update += new EventHandler(tongshi1.CloseStockMarket);                              //            然后将该实例注册给Boss中的Update委托；
            boss.Update += new EventHandler(tongshi2.CloseNBADirecteSeeding);                        //          4.修改输出Boss的SubjectState（输出内容）的内容，用于后于后面；
            //                                                                                       //          5.调用Boss的Notify方法（Notify方法中Update方法输出），然后输出结果。
            boss.SubjectState = "我是老板，我回来了\t";
            boss.Notify();
            Console.Read();
        }
    }

---

 abstract class ProObserver
    {
        public abstract void Update();
    }

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

---

 abstract  class ProSubject
    {
        private List<ProObserver> observers = new List<ProObserver>();

        public void Attach(ProObserver observer)
        {
            observers.Add(observer);
        }
        public void Detch(ProObserver observer)
        {
            observers.Remove(observer);
        }
        public void Notify()
        {
            foreach (var item in observers)
            {
                item.Update();
            }
        }
        public  string SubjectState { get; set; }
    }
    class ConcreteSubject:ProSubject
    {
        private string subjectState;         
        public new string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
    }

---

 /// <summary>
    /// 用在事件委托实现
    /// </summary>
    interface Subject
    {
        void Notify();
        string SubjectState
        {
            get; set;
        }
    }




    interface ISubject
    {
        void Attach(Observer observer);
        void Detach(Observer observer);
        void Notify();
        string SubjectState
        {
            get; set;
        }
    }

    //class Boss : ISubject
    //{
    //    private List<Observer> observers = new List<Observer>();
    //    private string action;
    //    public string SubjectState
    //    {
    //        get
    //        {
    //            return action;
    //        }
    //        set
    //        {
    //            action = value;
    //        }
    //    }

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

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

    //    public void Notify()
    //    {
    //        foreach (var item in observers)
    //        {
    //            item.MUpdate();
    //        }
    //    }
    //}
    //class Secretary : ISubject
    //{
    //    private List<Observer> observers = new List<Observer>();
    //    private string action;
    //    public string SubjectState
    //    {
    //        get
    //        {
    //            return action;
    //        }

    //        set
    //        {
    //            action = value;
    //        }
    //    }

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

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

    //    public void Notify()
    //    {
    //        foreach (var item in observers)
    //        {
    //            item.MUpdate();
    //        }
    //    }
    //}


    delegate void EventHandler();
    /// <summary>
    /// 用在事件委托实现
    /// </summary>
    class Boss : Subject
    {
        public event EventHandler Update;

        private string action;
        public string SubjectState
        {
            get
            {
                return action;
            }

            set
            {
                action = value;
            }
        }

        public void Notify()
        {
            Update();
        }
    }
    class Secretary : Subject
    {
        public event EventHandler Update;

        private string action;
        public string SubjectState
        {
            get
            {
                return action;
            }

            set
            {
                action = value;
            }
        }

        public void Notify()
        {
            Update();
        }
    }

---

 abstract class Observer
    {
        protected string name;
        protected ISubject sub;
        public Observer(string name, ISubject sub)
        {
            this.name = name;
            this.sub = sub;
        }
        public abstract void MUpdate();
    }

    //class StockObserver : Observer
    //{
    //    public StockObserver(string name, ISubject sub) : base(name, sub)
    //    {
    //    }

    //    public override void MUpdate()
    //    {
    //        Console.WriteLine("{0}{1}关闭Stock List ，毛毛都的无聊生活，继续工作", sub.SubjectState, name);
    //    }
    //}
    //class NBAObserver : Observer
    //{
    //    public NBAObserver(string name, ISubject sub) : base(name, sub)
    //    {
    //    }

    //    public override void MUpdate()
    //    {
    //        Console.WriteLine("{0}{1}关闭NBA Televation，毛毛都的无聊生活，继续工作", sub.SubjectState, name);
    //    }
    //}

    /// <summary>
    /// 用在事件委托实现
    /// </summary>
    class StockObserver
    {
        private string name;
        private Subject sub;
        public StockObserver(string name, Subject sub)
        {
            this.name = name;
            this.sub = sub;
        }
        public void CloseStockMarket()
        {
            Console.WriteLine("{0}{1}关闭StockMarket,继续工作", sub.SubjectState, name);
        }

    }
    /// <summary>
    /// 用在事件委托实现
    /// </summary>
    class NBAObserver
    {
        private string name;
        private Subject sub;
        public NBAObserver(string name, Subject sub)
        {
            this.name = name;
            this.sub = sub;
        }
        public void CloseNBADirecteSeeding()
        {
            Console.WriteLine("{0}{1}关闭NBADirecteSeeding,继续工作", sub.SubjectState, name);
        }

    }

---

转载请注明出处!!!

欢迎加入951815219群聊，共享知识，讨论交流~