observe pattern 观察者模式

先看下观察者模式的定义:

      The Observer Pattern defines a one-to-many denpendency between objects so that when one object changes state, all of its dependents are notified and updated automatically.:观察者模式定义了对象间一对多依赖关系,使得当一个对象改变状态,则所有依赖于它的对象都会得到通知并被自动更新。

      观察者模式又叫发布-订阅(Publish--Subscribe)模式,模型—视图(Model/View)模式,源—监听器(Source/Listener)模式等。

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

      实现观察者模式比较直观的一种是“注册-----通知----撤销注册”的形式。

首先,观察者(Observer)将自己注册到主题对象(Subject)中,主题对象将观察者存放在一个容器(Container)中.

其次,主题对象发生了某种变化,从容器中得到所有注册过的观察者,将变化通知观察者。

最后,观察者告诉主题对象要撤销观察,主题对象从容器中将观察者去除。

      观察者将自己注册到主题对象的容器中时,主题对象不应该过问观察者的具体类型,而是使用观察者的接口。这样做的优点是:假定程序中还有别的观察者,那么只要这个观察者也是相同的接口实现即可。一个主题对象可以对应多个观察者,当主题对象发生变化的时候,他可以将消息一一通知给所有的观察者。基于接口,而不是具体的实现------这一点为程序提供了更大的灵活性。

      举个例子:猫叫了一声,惊醒了主人,吓跑了老鼠。这个例子就可以用观察者模式来实现。猫是主题对象,主人和老鼠是观察者。具体实现类图如下:

observe pattern 观察者模式_第1张图片

C#代码实现:

public interface IObserver

    {

        void Update();

    }

    public interface ISubject

    {

        void AddObserver(IObserver obs);

        void RemoveObserver(IObserver obs);

        void Notify();

    }

    public class Mouse : IObserver

    {

        public void Update()

        {

            Console.WriteLine("Mouse is escaped");

        }

    }

    public class Master : IObserver

    {

        public void Update()

        {

            Console.WriteLine("Master is waken");

        }

    }

    public class Cat : ISubject

    {

        List list = new List();

        public void AddObserver(IObserver obs)

        {

            list.Add(obs);

        }

        public void RemoveObserver(IObserver obs)

        {

            list.Remove(obs);

        }

        public void Notify()

        {

            Console.WriteLine("Cat is crying");

            foreach (IObserver obs in list)

            {

                obs.Update();

            }

        }

}

static void Main(string[] args)

{

    IObserver mouse = new Mouse();

    IObserver master = new Master();

    ISubject cat = new Cat();

    cat.AddObserver(mouse);

    cat.AddObserver(master);

    cat.Notify();

}

      在.NET中,利用事件和委托来实现Observer模式更为简单,也是一中更好的解决方案。在C#的事件中,委托充当了抽象的Observer接口,而提供事件的对象充当了目标(Subject)对象。其实委托是比抽象Observer接口更为松耦合的设计,因为委托只要求挂接的方法的声明部分必须符合委托声明的格式,而不需要像接口一样必须要求类去完全实现之。观察者模式之所以叫观察者模式,并不是因为内部使用了ISubject,IObserver等来实现,而是因为这个模式解决了如下问题:“观察者模式定义了对象间的一种一对多依赖关系,使得每当一个对象改变状态,则所以依赖于它的对象都会得到通知并被自动更新”。也就是说,所有解决这个问题的方法都可以称作观察者模式。而且接口的概念也绝对不局限于C#里面的interface,接口只是一个契约,用来规范代码的行为,delegate也是一个接口,它规定了什么样的方法可以加载到delegate对应的event中,这也是一个契约,只是这个契约要比interface更简单。

下面我们用委托事件机制来实现上面的功能,代码如下:

public class Cat

        {

            public delegate void NotifyEventHandler();

            public event NotifyEventHandler NotifyEvent;

            public void Notify()

            {

                if (NotifyEvent != null)

                {

                    Console.WriteLine("Cat is crying");

                    NotifyEvent();

                }

            }

        }

        public class Master

        {

            public void Update()

            {

                Console.WriteLine("Master is waken");

            }

        }

        public class Mouse

        {

            public void Update()

            {

                Console.WriteLine("Mouse is escaping");

            }

        }

static void Main(string[] args)

{

  Cat cat = new Cat();

  Master master = new Master();

  Mouse mouse = new Mouse();

  Cat.NotifyEventHandler notifyMaster = new Cat.NotifyEventHandler(master.Update);

Cat.NotifyEventHandler notifyMouse = new Cat.NotifyEventHandler(mouse.Update);

  cat.NotifyEvent += notifyMaster;

  cat.NotifyEvent += notifyMouse;

  cat.Notify();

}

应用场景:

对一个对象状态的更新,需要其他对象同步更新,而且其他对象的数量动态可以变化。

对象仅需要将自己的更新通知给其他对象,而不需要知道其他对象的细节。

优点:

Subject 和obserer之间是送耦合的,分别可以各自独立改变。

Subject在发送广播通知的时候,无须指定具体的Observer,Observer可以自己决定是否需要订阅Subject的通知。

遵守大部分GRASP原则和常用设计原则,高内聚,低耦合。

缺点:

如果一个Subject被大量的Observer订阅的话,在广播通知的时候可能会有效率问题。

相关原则

我们知道设计原则远比模式重要,学习设计模式的同时一定要注意体会设计原则的理念。现在我们看看观察者模式都符合的设计原则。

Identify the aspects of your application that vary and separate them from what stays the same(找到系统中变化的部分,将变化的部分同其他稳定的部分隔开). 在观察者模式的应用场景里面变化的部分是Subject的状态和Observer的数量。使用Observer模式可以很好的将这两部分隔离开,我们可以任意改变Observer的数量而不需要去修改Subject, 而Subject的状态也可以任意修改,同样不会对其Observer有任何影响。

Program to an interface ,not an implementation(面向接口编程,而不要面向实现编程)  Subject和Observer都使用接口来实现。Subject只需要跟踪那些实现了IObserver接口的对象,所以其只依赖于IObserver;而所有Observer都通过ISubject接口来注册,撤销,接收通知,所有它们也只依赖于ISubject;所以是面向接口编程的,这样的实现方式使得Subject和Observer之间完全没有任何的耦合。

Favor composition over inheritance(优先使用对象组合,而非类继承) 观察者模式使用对象组合将Subject和若干Observer联系起来。它们之间的关系不是通过类的继承而是在运行时的动态组合。

原文转载出处:

https://blog.csdn.net/jxcr1984/article/details/53265038

你可能感兴趣的:(observe pattern 观察者模式)