观察者模式(Observer)——接口与委托实现

在程序中，有时候需要实现一种，当某一个对象（目标对象）的状态发生改变，所有依赖对象（观察者对象）都将得到通知。这个时候，就可以使用观察者模式（Observer）。

在GOF的设计模式中，这样说：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

虽然我读的是《Head Frist 设计模式》，但是，通过其中的例子，可以简单初级的了解这个思想~

在很多情况下，都可以看到观察者模式的例子。比如，如果你订阅了短信天气，那么，当天气突变的时候，就会收到短信提示。再比如~在家里做饭= =饭好了= =一嗓子吼着，吃饭啦。。。。好吧，大家就都来吃饭了。。。。

****************************代码部分（接口版本）*********************************

《Head Frist 设计模式》一书中，是java的代码，经过略微变化（甚至不需要，但是在有几个模式的例子中，必须改写），便可以完成观察者模式。

每一个观察者，都有一个Observer的接口，用以给目标对象调用。

而每一个目标对象，都有一个Subject接口，用以给每个观察者调用以产生订阅与退订的动作。

接口代码如下：

interface Subject
    {
        void registerObserver(Observer o);
        void removeObserver(Observer o);
        void notifyObservers();
    }
    interface Observer
    {
        void update(float temp, float humidity, float pressure);
    } 
   interface DisplayElement
    {
        void display();
    }

观察者，在创建的时候，就订阅了一个目标对象（其实也可以不这么处理，但是，估计是为了方便吧。。。。。。）

代码如下：

class CurrentConditionDisplay:Observer,DisplayElement
    {
        private float temperature;
        private float humidity;
        private Subject weatherData;

        public CurrentConditionDisplay(Subject weatherData)
        {
            this.weatherData = weatherData;
            weatherData.registerObserver(this);
        }

        public void update(float temperature, float humidity, float pressure)
        {
            this.temperature = temperature;
            this.humidity = humidity;
            display();
        }

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

目标对象，通过一个ArrayList来记录当前订阅了自己的所有观察者（其实也可以不用arraylist，如果在现在，我肯定用list。。。我也不知道我当时为啥用ArrayList）

代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;//用于实现arraylist

namespace ObserverPattern
{
    class WeatherData:Subject
    {
        private ArrayList observers;
        private float temperature;
        private float humidity;
        private float pressure;

        public WeatherData()
        {
            observers = new ArrayList();
        }

        #region
        public void registerObserver(Observer o)
        {
            observers.Add(o);
        }

        public void removeObserver(Observer o)
        {
            int i = observers.IndexOf(o);
            if (i >= 0)
                observers.Remove(i);
        }

        public void notifyObservers()
        {
            for (int i = 0; i < observers.Count; i++)
            {
                Observer observer = (Observer)observers[i];
                observer.update(temperature, humidity, pressure);
            }
        }

        #endregion

        public void measurementsChanged()
        {
            notifyObservers();
        }

        public void setMeasurements(float temperature, float humidity, float pressure)
        {
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            measurementsChanged();
        }

        //可加其余拓展的方法
    }
}

最后，main函数：

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

namespace ObserverPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            WeatherData weatherData = new WeatherData();

            CurrentConditionDisplay currentDisplay = new CurrentConditionDisplay(weatherData);

            weatherData.setMeasurements(80, 65, 30.4f);
            weatherData.setMeasurements(82, 70, 29.2f);
            Console.ReadKey();
        }
    }
}

运行结果图：

 

******************************华丽丽的分割线（委托版本）*********************************

那么，在java中是如此来实现，在.net中呢？还有一种方法：通过委托和事件来实现。（好吧，事件我还没看到。。。只写了委托的代码）

在C#中，我们可以不需要传一个observer给他，只需要给他一个委托（其实，委托，只需要参数和返回值一样，就可以传了，也就是，传的是一类的函数，A可以叫update，B可以叫myUpdate）。

在使用委托的时候，我同样的，对目标对象初始化的时候，就给他的委托字段附加上了一个空的函数，这样就可以避免null的问题了。

而目标对象，在发送通知的时候，直接一行搞定了~也许有人想说，利用接口去实现，可以保证，我只通知其中的一部分（私密通知~），而委托不行了吧？

其实，委托也可以的，委托也是可以遍历的，使用foreach(Delegate d in ***)就可以了。并且，在遍历的时候，还可以查看一些额外的信息哦~

如下，是观察者和目标对象的代码：

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

namespace ObserverPattern.Net
{
    public delegate void ObserverDelegate(string name);
    class Observer
    {
        private string name;
        public  void update(string SourceName)
        {
            Console.WriteLine("{0} 收到来自 {1} 的消息!", name, SourceName);
        }
        public Observer(string n)
        {
            name = n;
        }
    }

    class Source
    {
        private string name;
        private ObserverDelegate ObserverList;

        public Source(string n)
        {
            name = n;
            ObserverList = new ObserverDelegate(blankObserver);
        }
        private void blankObserver(string n) { }
        public void AddObserver(ObserverDelegate observer)
        {
            ObserverList += observer;
        }
        public void RemoveObserver(ObserverDelegate observer)
        {
            ObserverList -= observer;
        }
        public void update()
        {
            ObserverList(name);
        }
    }
}

主函数代码：

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

namespace ObserverPattern.Net
{
    class Program
    {
        static void Main(string[] args)
        {
            //初始化三个观察者
            List<Observer> observerList = new List<Observer>();
            observerList.Add(new Observer("obs1"));
            observerList.Add(new Observer("obs2"));
            observerList.Add(new Observer("obs3"));

            //初始化二个源
            Source source1 = new Source("source1");
            Source source2 = new Source("source2");

            //源1被订阅
            source1.AddObserver(observerList[0].update);
            source1.AddObserver(observerList[1].update);
            
            //源2被订阅
            source2.AddObserver(observerList[2].update);

            Console.WriteLine("*****第一次输出*****");
            source1.update();
            source2.update();
            
            //观察者2调整订阅目标
            source1.RemoveObserver(observerList[1].update);
            source2.AddObserver(observerList[1].update);

            Console.WriteLine("*****观察者2调整后的输出*****");
            source1.update();
            source2.update();

            Console.WriteLine("*****回车退出程序*****");
            Console.ReadLine();
        }
    }
}

结果截图：

*******************************我是分割线（小结部分）***********************************

小结：

感觉上，模式，算是一种思想了吧。实现方法其实很多种。在这里，就有2种方式了。但是，这2种方法也是有局限的。我比较怀疑在网络通信中，是否还可以这么方便的使用。就算是在同一台pc的不同程序间，估计也没这么简单的实现吧。（当然，也可能我孤陋寡闻了，主要在于阅历不足~）比如网络中，你至少需要记录一下对方的ip地址以及一些通信必要的东西吧。。

但是，我们只需要通过简单的例子来理解设计模式，然后，拖过它的思想，在可以使用的时候，去用这种思想去实现我们要的类似于——订阅广播——的功能。这样，可以是代码简洁而易懂。还记得在看设计模式中，一开始就说了共享模式词汇的威力。

简单的说，说一个模式名词，就意味着同时说了实现的思想，质量，特性，以及约束。并且，这一切，都是很简单的交流。

<script type="text/javascript"> </script><script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js"></script>