设计模式笔记8: 观察者模式

1.1　　定义

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

1.2　　类图

1.3　　代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式
{
    // 委托  
    delegate void EventHandler();

    // 此时若需要增加一个看NBA的同事，就需要修改原有的类，违背开放封闭原则，而且此时他们都依赖于细节又违背了依赖倒转原则
    // 所以我们抽象一个父类解决这个问题

    // 观察者父类
    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)
        {

        }
        // 通知
        public void CloseStockMarket()
        {
            Console.WriteLine("{0} {1} 关闭股票行情，继续工作！", sub.SubjectState, this.name);
        }
    }


    // 看NBA观察者
    class NBAObserver : Observer
    {
        public NBAObserver(string name, Subject sub) : base(name, sub) { }
        public void CloseNBAPlay()
        {
            Console.WriteLine("{0} {1} 关闭NBA直播，继续工作！", sub.SubjectState, this.name);
        }
    }



    // 通知者接口
    abstract class Subject
    {
        // 委托
        public EventHandler Update;
        public abstract void Notify();
        public string SubjectState { get; set; }
    }

    // 老板 实现通知者接口
    class Boss : Subject
    {
        public override void Notify()
        {
            Update();
        }
    }

    // 前台秘书
    // 前台秘书类也是一个具体的依赖，因为通知的对象可能是老板或其他对象。所以也需要抽象出来。
    class Secretary : Subject
    {
        // 通知
        public override void Notify()
        {
            Update();
        }
    }




}

调用：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 观察者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            // 前台
            Subject s = new Boss();
            // 看股票的同事
            StockObserver t1 = new StockObserver("熊大", s);
            NBAObserver t2 = new NBAObserver("熊二", s);

            // 前台记录两个同事
            //s.Attach(t1);
            //s.Attach(t2);
            //s.Detach(t1); // 熊大没有被通知到
            // 老板回来通知同事
            s.Update += new EventHandler(t1.CloseStockMarket);
            s.Update += new EventHandler(t2.CloseNBAPlay);
            s.SubjectState  = "我胡汉三回来了！";
            s.Notify();

        }
    }
}

1.4　　总结

　　我们定义观察者和通知者和通知者两个抽象父类都是为了面向抽象编程，以后再增加新的功能时增加新的类，而不修改原有的子类。 还有一个耦合：我们通知者对象通知观察者时执行的方法都是同一个方法。方法的执行体虽然已经被观察者重写，但是名字还是一致的。所以我们在通知者中增加了委托类型的成员，只需要将通知观察者的方法，注册给通知者的委托成员。这样就能完全自定义执行的方法了。