观察者模式

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

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


namespace 观察者模式
{
    abstract class Observer  //观察者
    {
        public abstract void Update();
    }
    abstract class Subject
    {
        private IList<Observer> observers = new List<Observer>();
        public void Attach(Observer o)
        {
            observers.Add(o);
        }
        public void Detach(Observer o)
        {
            observers.Remove(o);
        }
        public void Notify()
        {
            foreach (Observer o in observers)   //给所有登记过的观察者发出通知
            {
                o.Update();
            }
        }
    }
    class ConcreteSubject : Subject
    {
        private string state;          //主题状态变化
        public string State
        {
            get { return state; }
            set {   state=value;}
        }
    }
    class ConcreateObserver : Observer
    {
        private string name;
        private string Obstate;
        private ConcreteSubject subject;


        public ConcreateObserver(ConcreteSubject su, string name)
        {
            this.subject = su;
            this.name = name;
        }


        public override void Update()
        {
            Obstate = subject.State;        //使本事状态和主题的状态相协调
            Console.WriteLine("观察者{0}的新状态是{1}",name,Obstate);
        }


        public ConcreteSubject Subject
        {
            get { return subject;}
            set{subject=value;}
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteSubject s = new ConcreteSubject();


            s.Attach(new ConcreateObserver(s,"x"));
            s.Attach(new ConcreateObserver(s, "y"));


            s.State = "ABC";
            s.Notify();
        }
    }
}

观察者模式的关键对象是主题Subject和观察者Observer，一个Subject可以有任意数目的Oberver，一旦Subject的状态发生变化，所有的

Oberver都可以得到通知。