观察者模式（Observer pattern）

 知识点

　　使对象之间达到松耦合的效果。　

　　观察者模式定义了对象之间一对多的关系。主题用一个共同的接口来更新观察者。

　　观察者和被观察者之间通过松耦合的方式结合，被观察者不用理会观察者的实现细节，只需要观察者实现了观察接口（即所谓的注册）。

 示例代码

    public interface Subject
    {
        void RegisterObserver(Observer Observer);
        void RemoveObserver(Observer Observer);
        //当主题发生改变时，该方法会被调用，即通知所有观察者
        void NotifyObserver();
    }

    //主题（被观察的对象）
    public class WeatherData : Subject
    {
        private List<Observer> observers;

        public float Temperature
        {
            get;
            private set;
        }

        public float Humidity
        {
            get;
            private set;
        }

        public float Pressure
        {
            get;
            private set;
        }

        public WeatherData() {
            observers = new List<Observer>();
        }

        #region Subject 成员

        public void RegisterObserver(Observer Observer)
        {
            observers.Add(Observer);//注册观察者
        }

        public void RemoveObserver(Observer Observer)
        {
            observers.Remove(Observer);//取消观察者的的注册
        }

        public void NotifyObserver()
        {
            observers.ForEach(o => {
                ((Observer)o).Update(Temperature, Humidity, Pressure);
            });
        }

        #endregion

        public void DataChanged() {
            NotifyObserver();
        }

        public void SetMeasurements(float temp, float humidity, float pressure) {
            Temperature = temp;
            Humidity = humidity;
            Pressure = pressure;
            DataChanged();
        }
    }

    //观察者更新数据接口
    public interface Observer
    {
        void Update(float temp,float humidity,float pressure);
    }

    //显示数据接口
    public interface DispalyElement
    {
        void Dispay();
    }

    //观察者
    public class CurrentConditionDisplay : Observer, DispalyElement
    {
        readonly Subject _subject;
        public Subject Subject
        {
            get
            {
                return _subject;
            }
        }

        public float Temperature
        {
            get;
            private set;
        }

        public float Humidity
        {
            get;
            private set;
        }

        public CurrentConditionDisplay(Subject subject)
        {
            _subject = subject;
            _subject.RegisterObserver(this);
        }


        #region Observer 成员

        public void Update(float temp, float humidity, float pressure)
        {
            Temperature = temp;
            Humidity = humidity;
            Dispay();
        }

        #endregion

        #region DispalyElement 成员

        public void Dispay()
        {
            Console.WriteLine("{0}F {1}%", this.Temperature, this.Humidity);
        }

        #endregion
    }

最后来调用测试一下：

小结

　　观察者模式定义了对象之间一对多的依赖，当一个状态发生改变时，它的所有依赖都会收到通知并自动更新。　　

　　观察者模式的作用，当两个对象之间松耦合，它们依然可以交互，但是不用关注彼此之间实现的细节。