《大话设计模式》读书笔记-观察者模式

应用场景：当一个对象的改变需要同时改变其他对象的时候。

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

// 通知者接口，里面包含了观察者接口
    interface Subject
    {
        void Attach(Observer observer);
        void Detach(Observer observer);
        void Notify();

        string SubjectState { get;set;}
    }

// 老板类，实现了通知者接口，是具体的通知者。类内部包含了观察者接口的引用
    class Boss:Subject
    {
        // 同事列表
        private IList<Observer> observers = new List<Observer>();
        private string action;

        // 加入要通知的观察者
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }

        // 去除要通知的观察者
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }

        // 通知观察者，观察者执行Update方法
        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
            }
        }

        // 通知者的状态，此状态变化时，通知观察者
        public string SubjectState
        {
            get
            {
                return action;
            }
            set
            {
                action = value;
            }
        }
    }

// 前台秘书类 实现了通知者接口，是具体的通知者。类内部包含了观察者接口的引用
    class Secretary:Subject
    {
        // 同事列表
        private IList<Observer> observers = new List<Observer>();
        private string action;

        // 加入要通知的观察者
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }

        // 去除要通知的观察者
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }

        // 通知观察者，观察者执行Update方法
        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
            }
        }

        // 通知者的状态，此状态变化时，通知观察者
        public string SubjectState
        {
            get
            {
                return action;
            }
            set
            {
                action = value;
            }
        }
    }

 // 抽象观察者类，内部包含了通知者类的对象
    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 StockObserver:Observer
    {
        public StockObserver(string name, Subject sub)
            : base(name, sub)
        {
        }

        // 重写了Update方法
        public override void Update()
        {
            Console.WriteLine("{0}{1} 关闭股票行情，继续工作!",sub.SubjectState,name);
        }
    }

 

 // 具体的NBA观察者类
    class NBAObserver:Observer
    {
        public NBAObserver(string name, Subject sub)
            : base(name, sub)
        {
        }

        public override void Update()
        {
            Console.WriteLine("{0}{1} 关闭NBA，继续工作!",sub.SubjectState,name);
        }
    }

 

// 客户端掉用代码 
static void Main(string[] args)
        {
            // 老板胡汉三
            Boss huhansan = new Boss();

            // 看股票的同事，将通知者加入到观察者对象中去
            StockObserver tongshi1 = new StockObserver("魏关姹",huhansan);

            // 看NBA的同事
            NBAObserver tongshi2 = new NBAObserver("易管查",huhansan);

            // 通知者对象加入观察者对象
            huhansan.Attach(tongshi1);
            huhansan.Attach(tongshi2);

            // 去除观察者对象
            huhansan.Detach(tongshi1);

            //老板回来
            huhansan.SubjectState = "我胡汉三又回来了";

            //发出通知
            huhansan.Notify();

            Console.ReadKey();
        }

转载于:https://www.cnblogs.com/liming1019/archive/2010/01/15/1648842.html