观察者（发布订阅）模式 与 委托事件

多一些宽容

重点概念

1. 开放封闭原则，修改原有代码就说明不够好，依赖倒转原则，应该让程序依赖抽象不依赖细节。

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

3. 上图中Subject类，是抽象通知者（主题），一般用一个抽象类或者一个接口实现。他把所有观察者（关注Subject变化的类）的引用保存在一个集合里面，当Subject发生变化，就遍历调用所有观察者的方法或者状态。

4. Observer 类，是抽象观察者，为所有具体观察者定义一个接口，在得到通知者的通知时更新自己。这个接口叫做更新接口，Update();

5. ConcreteSubject 类，是具体主题或具体通知者，将有关状态存如具体观察者对象，在具体主题的内部发生状态改变的时候，给所有登记过的观察者发出通知（也就是调用Observer的Update()接口），他继承自Subject（抽象通知者）类。

6. ConcreteObserver 类，具体观察者，实现抽象观察者角色所要求的更新接口Update()，以便使本身的状态与主题（通知者）的状态相协调。具体观察者可以保存一个指向具体主题对象的引用，观察者重点就是要实现Update()方法。

7. 将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相关对象间的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不便。

8. 当Subject （主题）改变了，Observer（观察主题的对象）也会随之得到改变的信息。

9. 当一个对象的改变需要同时改变其他的对象，而且不知道有多少对象需要改变时，可以考虑使用观察者模式

10. 观察者让耦合的双方都依赖与抽象，而不依赖与具体，从而使得各自的变化都不会影响到另一边的变化，做到了解除耦合的作用，依赖倒置原则的体现。

11. 委托就是一种引用方法的类型（方法类型）。一旦为委托分配了方法，委托将与该方法具有相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看作是对函数的抽象，是函数的‘类’，委托的实例将代表一个具体的函数。

12. 委托可以搭载多个方法，所有方法被依次调用。为委托赋值的方法不要求在同一个类中，只要他们的方法结构符合此委托定义的结构即可。

13.委托对象（事件）所搭载的所有所有方法必须具有相同的原型和形式，也就是拥有相同的参数列表和返回值类型。

 

 

示例程序

 

using System;
using System.Collections.Generic;
using System.Text;

namespace 观察者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            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();

        }
    }


    abstract class Subject
    {
        private IList<Observer> observers = new List<Observer>();

        //增加观察者
        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();
            }
        }
    }

    //具体通知者
    class ConcreteSubject : Subject
    {
        private string subjectState;

        //具体通知者状态
        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
    }


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

    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; }
        }
    }

}

委托版本的老板回来了

 

using System;
using System.Collections.Generic;
using System.Text;

namespace 观察者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            //老板胡汉三
            Boss huhansan = new Boss();

            //看股票的同事
            StockObserver tongshi1 = new StockObserver("魏关姹", huhansan);
            //看NBA的同事
            NBAObserver tongshi2 = new NBAObserver("易管查", huhansan);

            //事件也是变量，需要赋值才会执行相应的动作，
            //在这里为事件Update，赋值了两个委托方法，当调用Update事件的时候，会按顺序相应的调用这两个方法。
            //通过委托将本不相关的方法相连
            huhansan.Update += new EventHandler(tongshi1.CloseStockMarket);
            huhansan.Update += new EventHandler(tongshi2.CloseNBADirectSeeding);

            //老板回来
            huhansan.SubjectState = "我胡汉三回来了！";
            //发出通知
            huhansan.Notify();

            Console.Read();


        }
    }

    //通知者接口
    interface Subject
    {
        void Notify();
        string SubjectState
        {
            get;
            set;
        }
    }

    //事件处理程序的委托
    delegate void EventHandler();

    class Secretary : Subject
    {
        //声明一事件Update，类型为委托EventHandler
        public event EventHandler Update;

        private string action;

        public void Notify()
        {
            Update(); //调用事件
        }
        public string SubjectState
        {
            get { return action; }
            set { action = value; }
        }
    }


    /// <summary>
    /// 这个类在客户端代码中被用到
    /// </summary>
    class Boss : Subject
    {
        //声明一事件Update，类型为委托EventHandler
        public event EventHandler Update;

        private string action;

        public void Notify()
        {
            Update(); //调用事件
        }
        public string SubjectState
        {
            get { return action; }
            set { action = value; }
        }
    }

    //看股票的同事
    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} 关闭股票行情，继续工作！", sub.SubjectState, name);
        }
    }

    //看NBA的同事
    class NBAObserver
    {
        private string name;
        private Subject sub;
        public NBAObserver(string name, Subject sub)
        {
            this.name = name;
            this.sub = sub;
        }

        //关闭NBA直播
        public void CloseNBADirectSeeding()
        {
            Console.WriteLine("{0} {1} 关闭NBA直播，继续工作！", sub.SubjectState, name);
        }
    }
}