初涉c#设计模式-Observer Pattern-从公司管理系统删单提醒开始

观察者模式：

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

• 抽象主题（Subject）角色：主题角色把所有对观察考对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，主题角色又叫做抽象被观察者（Observable）角色，一般用一个抽象类或者一个接口实现。
• 抽象观察者（Observer）角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。抽象观察者角色一般用一个抽象类或者一个接口实现。在这个示意性的实现中，更新接口只包含一个方法（即Update()方法），这个方法叫做更新方法。
• 具体主题（ConcreteSubject）角色：将有关状态存入具体现察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者角色（Concrete Observable）。具体主题角色通常用一个具体子类实现。
• 具体观察者（ConcreteObserver）角色：存储与主题的状态自恰的状态。具体现察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体现察者角色可以保存一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。

从具体主题角色指向抽象观察者角色的合成关系，代表具体主题对象可以有任意多个对抽象观察者对象的引用。之所以使用抽象观察者而不是具体观察者，意味着主题对象不需要知道引用了哪些ConcreteObserver类型，而只知道抽象Observer类型。这就使得具体主题对象可以动态地维护一系列的对观察者对象的引用，并在需要的时候调用每一个观察者共有的Update()方法。这种做法叫做"针对抽象编程"。（参考吕震宇老师的博客）

 

Observer Pattern发展到现在已经演变成好好几个版本，最为经典的还是老鼠出洞的例子，此时，猫开始跑起去抓老鼠，这是单任务，而加上娃娃开始哭，这就成了观察者的多任务，用到自己工作中去，在公司的内部管理系统中，当其中一个部门将一个客户删除之后，同时把这个消息通知到其他部门的每个工作人员，这个时候我们便可以使用观察者模式的多任务模式。

当单任务的时候我们可以通过对象的引用，直接调用此任务方法，但为多任务的时候，我们可以选择使用List<对象>，在被观察者行动的时候，由被观察者自身遍历所有的对象，进行通知，简单的，我们可以使用delegate注册对象，最后通过触发事件通知到每一个观察者。

首先来看代码：

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

namespace ObserverPattern
{
    //定义删单抽象接口
    public interface Observable
    {
        void Delete(int id);
    }
    //合作部类，可以删除单子，这个时候通知到注册到代理事件中的每一个对象，调用更新方法
    class CooperationObservable:Observable
    {
        public delegate void iDelegate(int id);
        public event iDelegate aDeletage;
        public void Delete(int id)
        {
            aDeletage(id);
        }
    }
    //观察者接口
    public interface Observer
    {
        void Update(int id);
    }
    //观察者对象
    class ConcreateObserver : Observer
    {
        string name;
        public string Name
        {
            set { name = value; }
            get { return name; }
        }
        public ConcreateObserver(string aname)
        {
            name = aname;
        }
        //进行更新
        public void Update(int id)
        {
            Console.WriteLine(Name+"："+id+"单子被删除");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //三个观察者
            ConcreateObserver aObserver = new ConcreateObserver("王瑞");
            ConcreateObserver bObserver = new ConcreateObserver("王玲玲");
            ConcreateObserver cObserver = new ConcreateObserver("魏晴");
            CooperationObservable aSubject = new CooperationObservable();
            aSubject.aDeletage += new CooperationObservable.iDelegate(aObserver.Update);
            aSubject.aDeletage += new CooperationObservable.iDelegate(bObserver.Update);
            aSubject.aDeletage += new CooperationObservable.iDelegate(cObserver.Update);
            aSubject.Delete(15);
        }

    }
}

当然，如果我们非要使用delegate实现的话，这段代码还有很大的优化空间。因为delegate本身就实现了抽象，它就是针对接口进行编程，我们完全可以在我们需要的时候注册到delegate中我们需要的方法。

来看不适用delegate的情况：

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

namespace ObserverPattern
{
    //定义删单抽象接口
    public interface Observable
    {
        void Delete(int id);
    }
    //合作部类，可以删除单子，实现注册方法，将观察者注册到观察者列表当中
    class CooperationObservable:Observable
    {
        List<Observer> listObserver = new List<Observer>();
        public void Delete(int id)
        {
            foreach(Observer i in listObserver)
                i.Update(id);
        }
        public void Register(Observer aObserver)
        {
            listObserver.Add(aObserver);
        }
    }
    //观察者接口
    public interface Observer
    {
        void Update(int id);
    }
    //观察者对象
    class ConcreateObserver : Observer
    {
        string name;
        public string Name
        {
            set { name = value; }
            get { return name; }
        }
        public ConcreateObserver(string aname)
        {
            name = aname;
        }
        //进行更新
        public void Update(int id)
        {
            Console.WriteLine(Name+"："+id+"单子被删除");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //三个观察者
            ConcreateObserver aObserver = new ConcreateObserver("王瑞");
            ConcreateObserver bObserver = new ConcreateObserver("王玲玲");
            ConcreateObserver cObserver = new ConcreateObserver("魏晴");
            CooperationObservable aSubject = new CooperationObservable();
            aSubject.Register(aObserver);
            aSubject.Register(bObserver);
            aSubject.Register(cObserver);
            aSubject.Delete(15);
        }

    }
}

Observer Pattern有好多实现方式，比如上面的代码，我们可以在观察者中实现注册方法，效果是一样的。

观察者模式的优缺点

Observer模式的优点是实现了表示层和数据逻辑层的分离，并定义了稳定的更新消息传递机制，类别清晰，并抽象了更新接口，使得可以有各种各样不同的表示层（观察者）。

但是其缺点是每个外观对象必须继承这个抽像出来的接口类，这样就造成了一些不方便，比如有一个别人写的外观对象，并没有继承该抽象类，或者接口不对，我们又希望不修改该类直接使用它。虽然可以再应用Adapter模式来一定程度上解决这个问题，但是会造成更加复杂烦琐的设计，增加出错几率。

观察者模式的效果有以下几个优点：

（1）观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体现察者聚集，每一个具体现察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。

（2）观察者模式支持广播通信。被观察者会向所有的登记过的观察者发出通知。

观察者模式有下面的一些缺点：

（1）如果一个被观察者对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

（2）如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察考模式时要特别注意这一点。

（3）如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。

（4）虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。

 

转载请注明出处：Edward_jie,http://www.cnblogs.com/promise-7