C#设计模式之观察者

来源：互联网发布：alexnet网络详解编辑：程序博客网时间：2024/05/22 07:07

Iron之观察者

引言

上一篇说的职责链模式，很有意思的一个模式，今天这个模式也是很有意思的一个模式，还是不啰嗦了直接进入主题吧。

场景介绍：在上一遍中说到用到部件检测，很巧妙的让调用者和处理者解耦了（没有看过上篇的文章也没关系，只是剧情是要接着发展的），要把部件拿去检测是要让个人来盯着看呢？还是部件生产好了自动就被拿去检测了呢？毋庸置疑必须是自动化的。

看一下部件的结构

 1     /// <summary> 2     /// 部件 3    /// </summary> 4     public class ComponentModel 5     { 6         public string Name { get; set; } 7         public int Value 8         { 9             get10             {11                 return 5;12             }13         }14 15     }

这个部件还是上一篇的部件，没有做任何改动。只是示例，为了让没看过上一篇的朋友知道。

按照场景里所要求的，定义了下面的两个类型，ComponentModelFactory类型，ComponentModel类型工厂负责生产ComponentModel部件，并且在完成时通知要另外处理部件的对象。
ExecutionCheck类型，就是要要被通知到的对象，它等待着别人告诉它 “有部件生产好了，需要被你送去检测”，不会它会很无聊。

 1    /// <summary> 2    /// 示例ComponentModel类型工厂 生产了ComponentModel 通知ExecutionCheck对象去检测 3    /// </summary> 4     public class ComponentModelFactory 5     { 6         public static ComponentModel ComModelFactory() 7         { 8             return new ComponentModel(); 9         }10     }11     /// <summary>12     /// 送ComponentModel对象去检测13    /// </summary>14     public class ExecutionCheck15     {16         public void ComponentModelCheck(ComponentModel comModel)17         {18             //送去执行检测19             //或者是一些其他操作20         }21     }

来看看调用代码：

1 ExecutionCheck executionCheck = new ExecutionCheck();2 executionCheck.ComponentModelCheck(ComponentModelFactory.ComModelFactory());3 executionCheck.ComponentModelCheck(ComponentModelFactory.ComModelFactory());4 executionCheck.ComponentModelCheck(ComponentModelFactory.ComModelFactory());

似乎是解决了问题，但是结果糟透了，虽然executionCheck很高兴，因为它有活干了，我只能以这样的方式去通知executionCheck，或许有人说修改下ComponentModelFactory类型会好一点，我知道是这样的：

 1     public class ComponentModelFactory 2     { 3         public static ComponentModel ComModelFactory() 4         { 5             return new ComponentModel(); 6         } 7         public void PastMessage(ComponentModel componentModel,ExecutionCheck executionCheck) 8         { 9             executionCheck.ComponentModelCheck(componentModel);10         }11     }

调用代码则调整为：

1 ComponentModelFactory componentModelFactory = new ComponentModelFactory();2 ExecutionCheck executionCheck=new ExecutionCheck();3 componentModelFactory.PastMessage(ComponentModelFactory.ComModelFactory(), executionCheck);

这样的结果，调用方式没问题了，可是ComponentModelFactory类型的内部居然有着这样高的耦合，无法忍受，必须得找出一种方式或者模式来解决这样的难题，不然寝食难安！！！！

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

——Gof

按照模式的定义重新来过（会有点不一样的地方中心思想不变），先对ExecutionCheck 类型进行抽象

 1     /// <summary> 2     /// 抽象的ExecutionCheck（抽象观察者） 3     /// </summary> 4     public abstract class ABSExecutionCheck 5     { 6         public abstract void ComponentModelCheck(ComponentModel comModel); 7     } 8  9     /// <summary>10     /// 送ComponentModel对象去检测（观察者）11     /// </summary>12     public class ExecutionCheck:ABSExecutionCheck13     {14         public override void ComponentModelCheck(ComponentModel comModel)15         {16             //送去执行检测17             //或者是一些其他操作18         }19     }

然后再对ComponentModelFactory进行改造，并且抽象它。

 1     /// <summary> 2     /// 抽象目标 3     /// </summary> 4     public abstract class ABSComponentModelFactory 5     { 6         protected ABSExecutionCheck absExecutionCheck; 7         public abstract void RegisterABSExecutionCheck(ABSExecutionCheck executionCheck); 8         public abstract void ClearABSExecutionCheck(); 9         public abstract void PastMessage(ComponentModel componentModel);10     }

ABSComponentModelFactory类型是要让ComponentModelFactory类型实现的，从这里可以看出是遵循设计原则的面对抽象编程的，当然了最后一个PastMessage函数忽略掉，现在来看一下实现了抽象目标ABSComponentModelFactory的ComponentModelFactory（具体目标）的实现。

 1     /// <summary> 2     /// 示例ComponentModel类型工厂 生产了ComponentModel 通知ExecutionCheck对象去检测  (具体目标） 3     /// </summary> 4     public class ComponentModelFactory:ABSComponentModelFactory 5     { 6         public static ComponentModel ComModelFactory() 7         { 8             return new ComponentModel(); 9         }10 11         public override void RegisterABSExecutionCheck(ABSExecutionCheck executionCheck)12         {13             absExecutionCheck = executionCheck;14         }15 16         public override void ClearABSExecutionCheck()17         {18             absExecutionCheck = null;19         }20         public override void PastMessage(ComponentModel componentModel)21         {22             absExecutionCheck.ComponentModelCheck(componentModel);23         }24     }

现在再来看一下调用的代码：

1 ABSExecutionCheck executionCheck = new ExecutionCheck();2 ABSComponentModelFactory componentModelFactory = new ComponentModelFactory();3 componentModelFactory.RegisterABSExecutionCheck(executionCheck);4 componentModelFactory.PastMessage(ComponentModelFactory.ComModelFactory());

这样就比较稳固了，在第一行new ExecutionCheck()的地方可以动态注入，和最后行的工厂生产对象一样。因为这里只是示例就不会很严谨。还有要说的就是定义中是一对多，这样可以修改ABSComponentModelFactory类型中的字段，修改为集合类型就可以了。把对应的实现类也适当的修改一下就可以了。

观察者就讲到这里。下一篇是外观，敬请期待。

作者：金源

出处：http://blog.csdn.net/jinyuan0829

本文版权归作者和CSDN共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面

0 0