• 设计模式——观察者模式


    定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

    这种交互方式也被叫做发布—订阅

    观察者模式中关键的对象是目标和观察者。

    一个目标可以由任意数目的依赖它的观察者。一旦目标的状态发生改变,所有的观察者都得到通知。作为对这个通知的相应,每个观察者都查询目标以使其状态与目标状态同步。

    目标发布事件,观察者订阅事件。被观察者不需要知道是谁订阅了事件,可以有任意数目的观察者订阅事件。

    Subject( 目标)

    ——目标知道它的观察者,可以有任意多个观察者观察目标

    ——提供注册和删除观察者对象的接口

    Observe(观察者)

    ——为那些目标状态改变需要获得通知的对象定义一个更新接口

    ConcreteSubject(具体目标)

    ——将有关状态存入各ConcreteObserve对象

    ——当它的状态改变时,向它的各个观察者发出通知

    ConcreteObserve(具体观察者)

    ——维护一个指向ConcreteSubject对象的引用

    ——储存有关状态,这些状体与目标的状态保持一致

    ——实现Observe的更新接口以使自身的状态与目标状态保持一致

    题目:猫大叫,两只老鼠开始逃跑,主人醒来,宝宝也醒来了并且哭了起来

    猫是目标由于它的某些动作才导致了以后的一系列事情发生

    C#语言使用委托以及事件,可以很好的实现观察者模式

    目标的基类

     1         /**//// <summary>
     2 
     3     ///     在Observer Pattern(观察者模式)中,此类作为所有Subject(目标)的抽象基类
     4 
     5     /// 所有要充当Subject的类(在此事例中为"猫")都继承于此类.
     6 
     7     ///     我们说此类作为模型,用于规划目标(即发布方)所产生的事件,及提供触发
     8 
     9     /// 事件的方法.
    10 
    11     ///     此抽象类无抽象方法,主要是为了不能实例化该类对象,确保模式完整性.
    12 
    13     ///     具体实施:
    14 
    15     ///     1.声明委托
    16 
    17     ///     2.声明委托类型事件
    18 
    19     ///     3.提供触发事件的方法
    20 
    21     /// </summary>
    22 
    23     public abstract class ModelBase
    24 
    25     {
    26 
    27         public ModelBase()
    28 
    29         {
    30 
    31         }
    32 
    33         /**//// <summary>
    34 
    35         /// 声明一个委托,用于代理一系列"无返回"及"不带参"的自定义方法
    36 
    37         /// </summary>
    38 
    39         public delegate void SubEventHandler(); 
    40 
    41         /**//// <summary>
    42 
    43         /// 声明一个绑定于上行所定义的委托的事件
    44 
    45         /// </summary>
    46 
    47         public event SubEventHandler SubEvent;
    48  
    49 
    50         /**//// <summary>
    51 
    52         /// 封装了触发事件的方法
    53 
    54         /// 主要为了规范化及安全性,除观察者基类外,其派生类不直接触发委托事件
    55 
    56         /// </summary>
    57 
    58         protected void Notify()
    59         {
    60 
    61             //提高执行效率及安全性
    62 
    63             if(this.SubEvent!=null)
    64 
    65                 this.SubEvent();
    66         }
    67 
    68     }

    只完成一个动作观察者基类

     1    /**/
     2     /// <summary>
     3 
     4     ///     在Observer Pattern(观察者模式)中,此类作为所有Observer(观察者)的抽象基类
     5 
     6     /// 所有要充当观察者的类(在此事例中为"老鼠"和"人")都继承于此类.
     7 
     8     ///     我们说此类作为观察者基类,用于规划所有观察者(即订阅方)订阅行为.
     9 
    10     ///     在此事例中,规划了针对目标基类(ModelBase)中声明的"无参无返回"委托的一个
    11 
    12     /// 方法(Response),并于构造该观察者时将其注册于具体目标(参数传递)的委托事件中.
    13 
    14     ///     具体实施过程:
    15 
    16     ///     1.指定观察者所观察的对象(即发布方).(通过构造器传递)
    17 
    18     ///     2.规划观察者自身需要作出响应方法列表
    19 
    20     ///     3.注册需要委托执行的方法.(通过构造器实现)
    21 
    22     /// </summary>
    23     /// 
    24     abstract class Observer
    25     {
    26 
    27         /**//// <summary>
    28 
    29         /// 构造时通过传入模型对象,把观察者与模型关联,并完成订阅.    -单行为-
    30 
    31         /// 在此确定需要观察的模型对象.
    32 
    33         /// </summary>
    34 
    35         /// <param name="childModel">需要观察的对象</param>
    36 
    37         public Observer(ModelBase childModel)
    38 
    39         {
    40 
    41             //订阅
    42 
    43             //把观察者行为(这里是Response)注册于委托事件
    44 
    45             childModel.SubEvent+=new ModelBase.SubEventHandler(Response);
    46 
    47         }
    48 
    49  
    50 
    51         /**//// <summary>
    52 
    53         /// 规划了观察者的一种行为(方法),所有派生于该观察者基类的具体观察者都
    54 
    55         /// 通过覆盖该方法来实现作出响应的行为.
    56 
    57         /// </summary>
    58 
    59         public abstract void Response();
    60     }

    需完成两个动作的观察者基类

     1          /**//// <summary>
     2  
     3      /// 定义了另一个观察者基类.该观察者类型拥有两个响应行为.
     4 
     5     /// 并在构造时将响应行为注册于委托事件.
     6 
     7     /// (具体描述请参照另一观察者基类Observer)
     8 
     9     /// </summary>
    10     abstract class Observer2
    11     {
    12          /**//// <summary>
    13 
    14         /// 构造时通过传入模型对象,把观察者与模型关联,并完成订阅.
    15 
    16         /// 在此确定需要观察的模型对象.
    17 
    18         /// </summary>
    19 
    20         /// <param name="childModel">需要观察的对象</param>
    21         /// 
    22 
    23 
    24           public Observer2(ModelBase childModel)
    25 
    26         {
    27 
    28             //订阅
    29 
    30             //把观察者行为(这里是Response和Response2)注册于委托事件
    31 
    32             childModel.SubEvent+=new ModelBase.SubEventHandler(Response);
    33 
    34             childModel.SubEvent+=new ModelBase.SubEventHandler(Response2);
    35 
    36             
    37 
    38         }
    39 
    40         /**//// <summary>
    41 
    42         /// 规划了观察者的二种行为(方法),所有派生于该观察者基类的具体观察者都
    43 
    44         /// 通过覆盖该方法来实现作出响应的行为.
    45 
    46         /// </summary>
    47 
    48         public abstract void Response();
    49 
    50         public abstract void Response2();
    51     }

    实现目标类:猫

     1     /**//// <summary>
     2  
     3      ///     此类为观察者模式中的具体目标(即具体发布方),其继承于模型.
     4 
     5     /// 其中包含(调用)了在模型中被封装好的触发委托事件的方法.
     6 
     7     /// </summary>
     8     class Cat:ModelBase
     9     {
    10          public Cat()
    11 
    12         {
    13 
    14         }
    15 
    16         /**//// <summary>
    17 
    18         /// 定义了猫的一种行为----大叫
    19 
    20         /// </summary>
    21 
    22         public void Cry()
    23 
    24         {
    25 
    26             System.Console.WriteLine("Cat Cry..");
    27 
    28             //调用了触发委托事件的方法.
    29 
    30             //通知委托开始执行观察者已订阅的方法.
    31 
    32             this.Notify();  
    33 
    34          }
    35     }

    实现观察者:老鼠

     1       /**//// <summary>
     2 
     3     ///     此类为观察者模式中的具体观察者(即具体发布方),其继承于观察者基类.
     4 
     5     /// 其中覆盖了观察者基类规划好的方法,实现了响应的具体行为.
     6 
     7     /// </summary>
     8     class Mouse:Observer
     9     {
    10 
    11         /**//// <summary>
    12 
    13         /// 观察者可以拥有自己的成员(字段或者方法).
    14 
    15         /// 在此事例中增加了"老鼠的名字"
    16 
    17         /// </summary>
    18 
    19         private string name;
    20 
    21         /**//// <summary>
    22 
    23         ///     构造时确定观察者所需要观察的对象(具体目标),并传递给观察者基类构造器,
    24 
    25         /// 实现响应行为(方法)的订阅.另外,为观察者实例初始化成员.
    26 
    27         /// </summary>
    28 
    29         /// <param name="name">老鼠的名字</param>
    30 
    31         /// <param name="childModel">
    32 
    33         ///     需要观察的对象(发布方).
    34 
    35         ///     此处用模型基类来传递,是为了兼容所有派生于此模型的观察者,从而提高扩展性.
    36 
    37         /// </param>
    38 
    39         public Mouse(string name,ModelBase childModel):base(childModel)
    40 
    41         {
    42 
    43             //初始化字段(老鼠的名字)
    44 
    45             this.name=name;         
    46 
    47         }
    48 
    49         /**//// <summary>
    50 
    51         /// 覆盖了该类观察者需要作出的具体响应行为.
    52 
    53         /// 此行为已在观察者基类中注册于委托事件,由委托事件调度执行,不需要直接调用.
    54 
    55         /// </summary>
    56 
    57         public override void Response()
    58 
    59         {
    60 
    61             //具体响应内容
    62 
    63             System.Console.WriteLine(this.name+"开始逃跑");
    64 
    65         }
    66     }

    实现观察者:主人

     1      /**//// <summary>
     2  
     3      ///     此类为观察者模式中的具体观察者(即具体发布方),其继承于观察者基类.
     4 
     5     /// 其中覆盖了观察者基类规划好的方法,实现了响应的具体行为.
     6 
     7     /// </summary>
     8     class Master:Observer
     9     {
    10           /**//// <summary>
    11 
    12         ///     构造时确定观察者所需要观察的对象(具体目标),并传递给观察者基类构造器,
    13 
    14         /// 实现响应行为(方法)的订阅.
    15 
    16         /// </summary>
    17 
    18         public Master(ModelBase childModel):base(childModel)
    19 
    20         {
    21 
    22         }
    23 
    24  
    25 
    26         /**//// <summary>
    27 
    28         /// 覆盖了该类观察者需要作出的具体响应行为.
    29 
    30         /// 此行为已在观察者基类中注册于委托事件,由委托事件调度执行,不需要直接调用.
    31 
    32         /// </summary>
    33 
    34         public override void Response()
    35 
    36         {
    37 
    38             System.Console.WriteLine("主人醒来");
    39 
    40         }
    41     }

    实现观察者:小主人

     1     /**//// <summary>
     2 
     3     ///     此类为观察者模式中的具体观察者(即具体发布方),其继承了订阅了2个响应行为的
     4 
     5     /// 观察者基类.
     6 
     7     ///     其中覆盖了观察者基类规划好的二个方法,实现了响应的具体行为.
     8 
     9     /// </summary>
    10     class Master2:Observer2
    11     {
    12         /**//// <summary>
    13 
    14         ///     构造时确定观察者所需要观察的对象(具体目标),并传递给观察者基类构造器,
    15 
    16         /// 实现响应行为(方法)的订阅.
    17 
    18         /// </summary>
    19 
    20         public Master2(ModelBase childBase):base(childBase)
    21 
    22         {
    23 
    24         }
    25 
    26  
    27 
    28         /**//// <summary>
    29 
    30         /// 覆盖了该类观察者需要作出的具体响应行为.
    31 
    32         /// 此行为已在观察者基类中注册于委托事件,由委托事件调度执行,不需要直接调用.
    33 
    34         /// </summary>
    35 
    36         public override void Response()
    37 
    38         {
    39 
    40             Console.WriteLine("baby醒来。。。。");
    41 
    42  
    43 
    44         }
    45 
    46         /**//// <summary>
    47 
    48         /// 覆盖了该类观察者需要作出的另一个响应行为.
    49 
    50         /// </summary>
    51 
    52         public override void Response2()
    53 
    54         {
    55 
    56             Console.WriteLine("开始哭闹。。。。。");
    57 
    58         }
    59     }

    具体调用:

     1   //声明并实例化一个目标(即发布方)对象----猫
     2 
     3             Cat myCat=new Cat();
     4 
     5             //声明并实例化一个Mouse类型的观察者对象--名叫mouse1的老鼠.并把那只猫作为它所要观察的对象.
     6 
     7             Mouse myMouse1=new Mouse("mouse1",myCat);
     8 
     9             //类似地生成另一只名叫mouse2的老鼠(观察者),把同一只猫作为它的观察的对象.
    10 
    11             Mouse myMouse2=new Mouse("mouse2",myCat);
    12 
    13             //声明并实例化一个Master类型的观察者--主人,并同时把那只猫也作为他的观察对象.
    14 
    15             Master myMaster=new Master(myCat);
    16 
    17             //声明并实例化一个Master2类型的观察者--宝宝,同时把那只猫也
    18 
    19             Master2 myLittleMaster=new Master2(myCat);
    20 
    21  
    22 
    23             //猫大叫,并触发了委托事件,从而开始按顺序调用观察者已订阅的方法.
    24 
    25             myCat.Cry();
    26 
    27  
    28 
    29             Console.Read();

    学习于     https://www.cnblogs.com/promise-7/archive/2012/05/14/2500759.html

  • 相关阅读:
    算法解读:基本的算法
    算法解读:数据结构
    算法解读:s变量和数组
    软件测试之构建测试---BVT
    什么是算法?——算法轻松入门
    大道至简——软件工程实践者的思想读书笔记四
    软件测试之安装测试
    大道至简——软件工程实践者的思想读书笔记三
    软件测试人员成长必备知识篇
    大道至简——软件工程实践者的思想读书笔记二
  • 原文地址:https://www.cnblogs.com/cwmizlp/p/9068228.html
Copyright © 2020-2023  润新知