HeadFirst 设计模式-观察者模式

观察者模式

主要是定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。不用被动的实时去查询被主题的状态。交互对象之间是松耦合的。

这是一种主动将新消息通知。随后我们将看到由观察者自身判定是否需要最新的数据，主动的去获取通知。

具体的代码如下：

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace Observer
{
   
    interface Observer
    {
        void update(float temperature, float humidity, float pressure);
    }
    interface Subject
    {
        void registObserver(Observer o);
        void removeObserver(Observer o);
        void notifyObserver();
    }
    interface DisplayElement
    {
        void dispaly();
    }

    class WeatherData : Subject
    {
        private System.Collections.ArrayList observers;//这种方式类必须管理一个数据结构，当信息发生改变，通知每一个观察者
        //而这种行为应该独立出来，不是针对特殊的应用，在WeatherData中仅有自己的私有内部成员变量
        private float temperature;
        private float humidity;
        private float pressure;
        public WeatherData()
        {
            observers = new ArrayList();
        }
        public void registObserver(Observer o)//添加的对象是Observer
        {
            observers.Add(o);
        }
        public void removeObserver(Observer o)
        {
            int index = observers.IndexOf(o);
            if (index >= 0)
            {
                observers.RemoveAt(index);
            }
        }

        //通知所有的观察者
        public void notifyObserver()
        {
            foreach (Object o in observers)
            {
                Observer observer = (Observer)o;
                observer.update(temperature, humidity, pressure);
            }
        }
        public void setMeasurements(float temperature, float humidity, float pressure)
        {
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            notifyObserver();
        }
    }

    //实现两个接口
    class CurrentConditionsDisplay : Observer, DisplayElement
    {
        private float temperature;
        private float humidity;
        private float pressure;
        private Subject subject;

        public CurrentConditionsDisplay(Subject subject)//以Subject 作为参数，可为之后删除观察者提供对象
        {
            this.subject = subject;
            subject.registObserver(this);
        }
        public void update(float temperature, float humidity, float pressure)
        {
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            this.dispaly();

        }
        public void dispaly()
        {
            Console.WriteLine("Current conditions:" + temperature + " F degrees and " + humidity + " % humidity");
        }
    }


    //但是上面的方法是不是没有问题了呢，有一个关键的是，观察者是被动的接受信息,如果观察者只是想知道一些想了解的信息？？？
    //观察者模式的关键是每个观察者的内部都有一个更新函数。在主题对象中有一个列表控制着所有的观察者
    //修改方式如下

}

//@Author tj
//@Date:2014-2-19
//@Observer Model

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace Observer
{
    class Program
    {
        static void Main(string[] args)
        {
            WeatherData weatherData = new WeatherData();
            CurrentConditionsDisplay currentConditionDisplay = new CurrentConditionsDisplay(weatherData);
            weatherData.setMeasurements(80, 90, 30.4f);

           
            //以下使用接口
            Console.WriteLine("using Observable");

            WeatherData1 weatherData1 = new WeatherData1();
            CurrentConditionsDisplay1 currentConditionDisplay1= new CurrentConditionsDisplay1(weatherData1);
            weatherData1.setMeasurements(78, 80, 30.4f);
            Console.ReadLine();
        }
    }

   
    
    class Observer1
    {
         public virtual void update(Observable obj, Object arg){}//实现多态的方式
    }
    class Observable
    {
        bool changed;
        ArrayList observers;//对结构进行管理，可以独立于当前的天气预报的应用。
        public Observable()
        {
            changed = false;
            observers = new ArrayList();
        }
        public void addObserver(Observer1 o)
        {
            observers.Add(o);
        }
        public void deleteObservers(Observer1 o)
        {
            int index = observers.IndexOf(o);
            if (index >= 0)
            {
                observers.RemoveAt(index);
            }
        }
        public void notifyObservers(Object arg)
        {
            if (changed)
            {
                foreach(Object obj in observers)
                {
                    Observer1 observer = (Observer1)obj;
                    observer.update(this, arg);
                }
                changed = false;
            }
        }
        public void notifyObservers()
        {
            notifyObservers(null);
        }
        public void setChanged()
        {
            changed = true;
        }

        //为什么上面的不能采取这种方式呢，直接的在Subject中定义，因为我们要对观察者进行更新，更新的几个参数如何的能够显示在Subject中
        //这个类很巧妙的将参数换做为Observable，WeatherData继承此，那么当调用update时实质是调用WeatherData1中的数据于观察者中
    }
    class WeatherData1 : Observable
    {
        private float temperature;
        private float humidity;
        private float pressure;

        public WeatherData1() {}
        public float getTemperature() 
        {
            return temperature;
        }
        public float getHumidity() 
        {
            return humidity;
        }
        public float getPressure() 
        {
            return pressure;
        }
        public void setMeasurements(float temperature,float humidity,float pressure)
        {
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            measurementsChanged();
        }
        public void measurementsChanged()//观察者可以通过在类里面调用此函数，再触发状态的改变。也就是观察者主动获取数据的过程
        {
            setChanged();
            notifyObservers();
        }
    }
    class CurrentConditionsDisplay1:Observer1
    {
        Observable observerable;//观察对象
        private float temperature;
        private float humidity;
        public CurrentConditionsDisplay1(Observable observable)
        {
            this.observerable = observable;
            observable.addObserver(this);//
        }

       public  override void update(Observable obj, Object arg) 
        { 
            if (obj is WeatherData1)
            {
                WeatherData1 weatherData = (WeatherData1)obj;
                this.temperature = weatherData.getTemperature();
                this.humidity = weatherData.getHumidity();
                display();
            }
        }

        public void display()
        {
            Console.WriteLine("new current conditions:" + temperature + " F degrees and " + humidity + "%humidity");
        }
    }
}

运行结果：