观察者模式

观察者模式：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主体对象，这个主题对象在状态发生变化时，会通知所有观察者。当一个对象改变需要同时改变其他对象，而且他不知道具体有多少对象需要改变的时候，应该考虑使用观察者模式。

观察者结构图：

 使用场景：老板回来通知员工需要进入工作状态。

 定义观察者的抽象类：

    abstract class Observer
    {
        protected string name;
        protected ISubject sub;

        public Observer(string name, ISubject sub)
        {
            this.name = name;
            this.sub = sub;
        }

        public abstract void Update();
    }

 看NBA直播的同事：

//使用OO

    class NBAObserver : Observer
    {
        public NBAObserver(string name, ISubject sub)
            : base(name, sub)
        { }
        public override void Update()
        {
            //throw new NotImplementedException();
            Console.WriteLine("{0} {1}关闭NBA直播，继续工作！",sub.SubjectState,name);
        }
    }

//使用事件和委托

    class NBAObserver2
    {
        private string name;
        private ISubject2 sub;

        public NBAObserver2(string name, ISubject2 sub)
        {
            this.name = name;
            this.sub = sub;
        }
        public void CloseStockMarket()
        {
            Console.WriteLine("{0} {1}关闭NBA直播，继续工作！", sub.SubjectState, name);
        }
    }

  

看股票的同事：

//使用OO

    class StockObserver : Observer
    {
        public StockObserver(string name, ISubject sub) : base(name,sub)
        { }
        public override void Update()
        {
            //throw new NotImplementedException();
            Console.WriteLine("{0} {1}关闭股票行情，继续工作！",sub.SubjectState,name);
        }
    }

 

//使用事件和委托

    class StockObserver2
    {
        private string name;
        private ISubject2 sub;

        public StockObserver2(string name, ISubject2 sub)
        {
            this.name = name;
            this.sub = sub;
        }
        public void CloseNBA()
        {
            Console.WriteLine("{0} {1}关闭股票行情，继续工作！", sub.SubjectState, name);
        }
    }

上的身份是订阅者，下面定义发布者：

//使用OO

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

    class Boss : ISubject
    {
        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);
        }

        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
            }
        }

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

//使用事件和委托

    interface ISubject2
    {
        void Notify();
        string SubjectState
        {
            get;
            set;
        }
    }

    delegate void EventHandler();
    class Boss2 : ISubject2
    {
        public event EventHandler Update;
        private string action;

        public void Notify()
        {
            Update();
        }

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

主函数调用：

    class Program
    {
        static void Main(string[] args)
        {
            //观察者模式OO实现
            Boss huhansan = new Boss();
            StockObserver tongshi1 = new StockObserver("name1",huhansan);
            NBAObserver tonshi2 = new NBAObserver("name2", huhansan);
            huhansan.Attach(tongshi1);
            huhansan.Attach(tonshi2);
            huhansan.SubjectState = "我1回来了";
            huhansan.Notify();

            //观察者模式c#事件实现
            Boss2 huhansan2 = new Boss2();
            StockObserver2 tongshi3 = new StockObserver2("name3", huhansan2);
            NBAObserver2 tonshi4 = new NBAObserver2("name4", huhansan2);

            huhansan2.Update += new EventHandler(tongshi3.CloseNBA);
            huhansan2.Update += new EventHandler(tonshi4.CloseStockMarket);
            huhansan2.SubjectState = "我2回来了";
            huhansan2.Notify();

            Console.ReadKey();
        }
    }

 委托就是一种引用方法的类型，一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看做是对函数的抽象，是函数的一个类，委托实例代表一个具体的函数，而且一个委托可以搭载多个方法，所有方法被依次唤醒。