对同样集合对象的操作并不是唯一的,9.与别的连锁形式

using System;

namespace VisitorPattern
{
    class Failing : Action
    {
        public override void GetManConclusion(Man concreateElementA)
        {
            Console.WriteLine("{0}{1}时,闷头喝酒,谁也不用劝。", concreateElementA.GetType().Name, this.GetType().Name);
        }

        public override void GetWomanConclusion(Woman concreateElementB)
        {
            Console.WriteLine("{0}{1}时,眼泪汪汪,谁也劝不了。", concreateElementB.GetType().Name, this.GetType().Name);
        }
    }
}
using System;

namespace VisitorPattern
{
    class Amativenness : Action
    {
        public override void GetManConclusion(Man concreateElementA)
        {
            Console.WriteLine("{0}{1}时,凡事不懂也要装懂。", concreateElementA.GetType().Name, this.GetType().Name);
        }

        public override void GetWomanConclusion(Woman concreateElementB)
        {
            Console.WriteLine("{0}{1}时,遇事懂也装作不懂。", concreateElementB.GetType().Name, this.GetType().Name);
        }
    }
}

在软件开发进程中,对于系统中的有些对象,它们存款和储蓄在同一个集合collection中,且有着区别的品种,而且对于该集合中的目的,勉强可以一类称为访问者的靶子来做客,而且不相同的访问者其访问格局有所分裂。

事例1:顾客在杂货铺旅长选拔的商品,如苹果、图书等位居购物车中,然后到收银员处付款。在购物进程中,顾客需求对这几个商品进行走访,以便确认那么些商品的品质,之后收银员总计价格时也急需拜访购物车内顾客所挑选的货色。

那会儿,购物车作为二个ObjectStructure(对象组织)用于存款和储蓄各体系型的商品,而消费者和收银员作为走访这几个商品的访问者,他们须要对货品进行自小编批评和计价。差别门类的货品其访问情势也恐怕分歧,如苹果需求过秤之后再计价,而图书不必要。

using System;

namespace VisitorPattern
{
    class Amativenness : Action
    {
        public override void GetManConclusion(Man concreateElementA)
        {
            Console.WriteLine("{0}{1}时,凡事不懂也要装懂。", concreateElementA.GetType().Name, this.GetType().Name);
        }

        public override void GetWomanConclusion(Woman concreateElementB)
        {
            Console.WriteLine("{0}{1}时,遇事懂也装作不懂。", concreateElementB.GetType().Name, this.GetType().Name);
        }
    }
}

Woman.cs

6.形式的结合

情势实例与分析
相公和女生—访问者方式示例代码
系统布局
图片 1
Vistor: 抽象访问者  Action.cs

形式定义
访问者格局(Visitor
Pattern):表示一个功能于某指标组织中的各因素的操作,它使大家得以在不改变各因素的类的前提下定义效用于这个要素的新操作。访问者格局是一种对象行为型格局。
Visitor Pattern: Represent an operation to be performed on the elements
of an object structure. Visitor lets you define a new operation without
changing the classes of the elements on which it operates.
Frequency of use: low
UML图
图片 2

 

using System;

namespace VisitorPattern
{
    //成功
    class Success : Action
    {
        public override void GetManConclusion(Man concreateElementA)
        {
            Console.WriteLine("{0}{1}时,背后多半有一个伟大的女人。", concreateElementA.GetType().Name, this.GetType().Name);
        }

        public override void GetWomanConclusion(Woman concreateElementB)
        {
            Console.WriteLine("{0}{1}时,背后大多有一个不成功的男人。", concreateElementB.GetType().Name, this.GetType().Name);
        }
    }
}

Failing.cs

访问者情势涵盖如下剧中人物:
架空访问者(Vistor): —
为该对象组织中ConcreteElement的每八个类声Bellamy(Bellamy)个Visit操作。该操作的名字和特
征标识了发送Visit请求给该访问者的十三分类。这使得访问者能够规定正被访问成分
的有血有肉的类。这样访问者就足以经过该因素的特定接口直接待上访问它。
具体访问者(ConcreteVisitor): —
达成每一种由Visitor注明的操作。各种操作完结本算法的一部分,而该算法片断乃是
对应于结构中指标的类。ConcreteVisitor为该算法提供了上下文并蕴藏它的一些情状。
这一情况平常在遍历该组织的历程中积聚结果。
 抽象成分(Element):定义1个Accept操作,它以一个访问者为参数。
切切实实因素(ConcreteElement):
  达成Accept操作,该操作以一个访问者为参数。
对象组织(ObjectStructure): 能枚举它的要素。能够提供3个高层的接口以允许该访问者访问它的成分。能够是叁个复合或者1个集结,如二个列表或七个无序集聚。

using System;

namespace VisitorPattern
{
    class Man : Person
    {
        public override void Accept(Action visitor)
        {
            visitor.GetManConclusion(this);
        }
    }
}

形式分析
访问者方式中指标协会存款和储蓄了不一样体系的要素对象,以供不一致访问者访问。
访问者情势包涵多个层次结构,2个是访问者层次结构,提供了用空想来欺骗别人访问者和求实访问者,二个是因素层次结构,提供了抽象成分和现实性因素。
同一的访问者可以以不相同的主意访问分化的成分,相同的因素得以接受差异访问者以区别访问情势访问。在访问者方式中,增添新的访问者无须修改原有系统,系统具备较好的可扩充性。

4.适用性

Failing.cs

形式动机

10.总结与分析

情势定义
访问者方式(Visitor
Pattern):表示1个效益于某指标组织中的各因素的操作,它使大家能够在不更改各要素的类的前提下定义成效于那几个因素的新操作。访问者形式是一种对象行为型形式。
Visitor Pattern: Represent an operation to be performed on the elements
of an object structure. Visitor lets you define a new operation without
changing the classes of the elements on which it operates.
Frequency of use: low
UML图
图片 3

ConcreteVisitor: 具体访问者 Success.cs

9.与其他有关情势

using System.Collections.Generic;

namespace VisitorPattern
{
    //对象结构
    class ObjectStructure
    {
        private IList<Person> elements = new List<Person>();
        //增加
        public void Attach(Person element)
        {
            elements.Add(element);
        }
        //移除
        public void Detach(Person element)
        {
            elements.Remove(element);
        }
        //查看显示
        public void Display(Action visitor)
        {
            foreach (Person e in elements)
            {
                e.Accept(visitor);
            }
        }
    }
}
namespace VisitorPattern
{
    abstract class Person
    {
        //接受
        public abstract void Accept(Action visitor);
    }
}

•迭代器形式)由于访问者形式供给对指标组织实行操作,而指标组织本人是二个因素对象的集聚,因而访问者格局平常索要与迭代器方式联用,在对象组织中动用迭代器来遍历成分对象。

•组合情势)在访问者方式中,成分对象大概存在容器对象和叶子对象,由此得以构成组合格局来展开统一筹划。

情势适用条件
在以下意况下能够利用访问者格局:

二个对象协会包蕴众多档次的目的,希望对那几个指标实施部分依靠其实际项目标操作。在访问者中针对每一个具体的花色都提供了3个访问操作,差异门类的靶子足以有例外的拜访操作。

供给对三个对象组织中的对象举办过多见仁见智的还要不相干的操作,而要求幸免让这一个操作“污染”那一个目的的类,也不期望在增添新操作时修改那一个类。访问者形式使得我们得以将有关的造访操作集中起来定义在访问者类中,对象组织能够被三个不等的访问者类所使用,将目的自小编与目的的拜访操作分离。
 对象协会中目的对应的类很少改变,但每每索要在此目的协会上定义新的操作。

对于系统中的某个对象,它们存款和储蓄在同一个集结中,且独具分歧的档次,而且对于该集合中的对象,能够承受一类称为访问者的指标来访问,而且分化的访问者其访问格局有所不一样,访问者形式为杀鸡取卵那类难题而诞生。
在实质上运用时,对同样集合对象的操作并不是绝无仅有的,对同一的成分对象或者存在多种区别的操作方法。
并且这几个操作方法并不安宁,恐怕还索要充实新的操作,以满足新的事情须求。
那时候,访问者格局就是2个值得考虑的化解方案。
访问者情势的目标是包裹一些施加于某种数据结构成分之上的操作,一旦那一个操作要求修改的话,接受那么些操作的数据结构能够维持不变。为差异品类的成分提供各类访问操作方法,且能够在不修改原有系统的气象下扩充新的操作办法,那就是访问者方式的格局动机。

10.扩展

Amativenness.cs

ObjectStructure: 对象组织 ObjectStructure.cs

设计形式 ( 二十 ) 访问者格局Visitor(对象行为型)

ObjectStructure: 对象组织 ObjectStructure.cs

using System.Collections.Generic;

namespace VisitorPattern
{
    //对象结构
    class ObjectStructure
    {
        private IList<Person> elements = new List<Person>();
        //增加
        public void Attach(Person element)
        {
            elements.Add(element);
        }
        //移除
        public void Detach(Person element)
        {
            elements.Remove(element);
        }
        //查看显示
        public void Display(Action visitor)
        {
            foreach (Person e in elements)
            {
                e.Accept(visitor);
            }
        }
    }
}

对同样集合对象的操作并不是唯一的,对相同的因素对象恐怕存在各类不相同的操作办法。而且那一个操作办法并不平稳,假设对亟待追加新的操作,怎样满意新的工作需求?

ConcreteVisitor: 具体访问者 Success.cs

using System;

namespace VisitorPattern
{
    class Man : Person
    {
        public override void Accept(Action visitor)
        {
            visitor.GetManConclusion(this);
        }
    }
}

图片 4

using System;

namespace VisitorPattern
{
    class Woman : Person
    {
        public override void Accept(Action visitor)
        {
            visitor.GetWomanConclusion(this);
        }
    }
}
namespace VisitorPattern
{
    abstract class Action
    {
        //得到男人结论或女人反应
        public abstract void GetManConclusion(Man concreateElementA);
        //得到女人结论或男人反应
        public abstract void GetWomanConclusion(Woman concreateElementB);
    }
}

2.问题

情势优缺点
访问者格局的优点
 使得扩展新的拜会操作变得很简单。

将有关因素对象的拜访行为集中到2个访问者对象中,而不是散落到1个个的要素类中。
 能够跨过类的级差结构访问属于不一样的阶段结构的成分类。
 让用户能够在不修改现有类层次结构的状态下,定义该类层次结构的操作。
访问者情势的缺陷

扩充新的因素类很难堪。在访问者形式中,每扩展二个新的要素类都表示要在抽象访问者剧中人物中加进二个新的架空操作,并在每二个实际访问者类中追加对应的具体操作,违背了“开闭原则”的须要。

破坏封装。访问者格局须要访问者对象访问并调用每2个成分对象的操作,那代表成分对象有时候必须揭破一些投机的在那之中操作和个中景观,不然不能够供访问者访问。

using System;

namespace VisitorPattern
{
    class Woman : Person
    {
        public override void Accept(Action visitor)
        {
            visitor.GetWomanConclusion(this);
        }
    }
}

访问者情势的亮点:

•使得扩大新的拜会操作变得很不难。要是有个别操作正视于1个扑朔迷离的协会对象的话,那么一般而言,扩张新的操作会很复杂。而使用访问者情势,增添新的操作就象征扩展2个新的造访者类,因而,变得很不难。

•将关于因素对象的造访行为集中到四个访问者对象中,而不是分散到贰个个的因素类中。

•访问者格局能够跨过多少个类的阶段结构访问属于差异的等级结构的成员类。迭代子只好访问属于同3个档次等级结构的分子对象,而不可能访问属于不相同等级结构的靶子。访问者形式能够成功那或多或少。

•让用户能够在不改动现有类层次结构的情事下,定义该类层次结构的操作。

访问者方式的短处:

•扩大新的元素类很拮据。在访问者情势中,每扩充3个新的要素类都代表要在虚幻访问者剧中人物中加进1个新的指雁为羹操作,并在每二个实际访问者类中扩展对应的具体操作,违背了“开闭原则”的渴求。

•破坏封装。访问者格局供给访问者对象访问并调用每2个要素对象的操作,那意味成分对象有时候必须暴光一些自个儿的个中操作和中间景色,不然不能供访问者访问。

对于系统中的有个别对象,它们存款和储蓄在同一个会合中,且有着分化的体系,而且对于该集合中的目的,能够承受一类称为访问者的靶子来拜访,而且分裂的访问者其访问格局有所不一样,访问者方式为缓解那类难题而诞生。
在事实上行使时,对相同集合对象的操作并不是唯一的,对同样的要素对象或许存在二种差异的操作格局。
再正是那几个操作方式并不平稳,只怕还需求增添新的操作,以满意新的事务须求。
此刻,访问者格局正是3个值得考虑的缓解方案。
访问者形式的目标是包装一些施加于某种数据结构成分之上的操作,一旦这一个操作需求修改的话,接受那些操作的数据结构能够保持不变。为分化类其他要素提供多样造访操作方式,且能够在不改动原有系统的情事下扩大新的操作办法,那正是访问者格局的方式动机。

Client:客户类

5.结构

【参考文献】
《设计情势—可复用面向对象软件的底子》我: [美] 埃里克h Gamma / RichardHelm / 拉尔夫 Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—改良既有代码的设计》小编: 马丁 Fowler译者:候捷
中夏族民共和国电力出版社
《敏捷软件开发—原则、情势与实践》小编: 罗Bert C. 马丁 南开东军事和政院学出版社
《程序员修炼之道—从小工到大方》小编: Andrew Hunt / 大卫 托马斯电子工业出版社
《Head First 设计情势》我: Freeman 译者: O’Reilly Taiwan公司中中原人民共和国电力出版社
《设计形式之禅》 作者: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计方式纵横谈》 教授:李建忠
刘伟先生. 设计情势. 北京:北大东军大学出版社, 二〇一一.
刘伟同志. 设计形式实验和培养和磨练教程. 东京(Tokyo):南开东军事和政院学出版社, 2011.
《大话设计情势》 小编: 程杰 哈工业余大学学东军大学出版社
《C#图解教程》小编: 索利斯 译者: 苏林 / 朱晔 人民邮政和邮电通讯出版社
《你必须明白的.NET》我: 王涛
《项目中的.NET》小编: 李天平 电子工业出版社
《Microsoft .NET公司级应用架构划设想计》小编: (美)埃斯波西托等撰写 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客小编:吕震宇
http://www.cnblogs.com/terrylee 博客笔者:李会军
http://www.cnblogs.com/anlyren/ 博客小编:anlyren
http://www.cnblogs.com/idior 博客作者:idior
http://www.cnblogs.com/allenlooplee 博客小编:Allen lee
http://blog.csdn.net/ai92 博客小编:ai92
http://www.cnblogs.com/umlonline/ 博客作者:张传波
http://www.cnblogs.com/lovecherry/ 博客小编:LoveCherry 

情势优缺点
访问者形式的独到之处
 使得扩充新的走访操作变得很容易。

将有关因素对象的造访行为集中到3个访问者对象中,而不是散落到贰个个的要素类中。
 能够跨过类的级差结构访问属于区别的阶段结构的成分类。
 让用户能够在不修改现有类层次结构的景况下,定义该类层次结构的操作。
访问者形式的老毛病

扩展新的因素类很劳苦。在访问者情势中,每扩张二个新的要素类都表示要在抽象访问者角色中加进三个新的抽象操作,并在每1个现实访问者类中追加对应的具体操作,违背了“开闭原则”的需求。

破坏封装。访问者方式必要访问者对象访问并调用每三个要素对象的操作,那意味着成分对象有时候必须揭破一些友好的内部操作和个中意况,不然无法供访问者访问。

大家是了phppan提供贰个例证:

 

[php] view
plain
data-mod=”popu_168″> data-mod=”popu_168″> copy

 

data-mod=”popu_169″> print?

  1. <?php  
  2. /** 
  3.  * 访问者格局 
  4.  * @author guisu 
  5.  *  
  6.  */  
  7.   
  8. interface Visitor {  
  9.     public  class=”keyword”>function visitConcreteElementA(ConcreteElementA  class=”vars”>$elementA);  
  10.     public  class=”keyword”>function visitConcreteElementB(concreteElementB  class=”vars”>$elementB);  
  11. }  
  12.   
  13. interface Element {  
  14.     public  class=”keyword”>function accept(Visitor  class=”vars”>$visitor);  
  15. }  
  16.   
  17. /** 
  18.  * 具体的访问者1 
  19.  */  
  20. class ConcreteVisitor1  class=”keyword”>implements Visitor {  
  21.     public  class=”keyword”>function visitConcreteElementA(ConcreteElementA  class=”vars”>$elementA){  
  22.         echo  class=”vars”>$elementA->getName(), class=”string”>’ visitd by ConcerteVisitor1 <br />’;  
  23.     }  
  24.   
  25.     public  class=”keyword”>function visitConcreteElementB(ConcreteElementB  class=”vars”>$elementB){  
  26.         echo  class=”vars”>$elementB->getName(). class=”string”>’ visited by ConcerteVisitor1 <br />’;  
  27.     }  
  28.   
  29. }  
  30.   
  31. /** 
  32.  * 具体的访问者2 
  33.  */  
  34. class ConcreteVisitor2  class=”keyword”>implements Visitor {  
  35.     public  class=”keyword”>function visitConcreteElementA(ConcreteElementA  class=”vars”>$elementA){  
  36.         echo  class=”vars”>$elementA->getName(),    class=”string”>’ visitd by ConcerteVisitor2 <br />’;  
  37.     }  
  38.   
  39.     public  class=”keyword”>function visitConcreteElementB(ConcreteElementB  class=”vars”>$elementB){  
  40.         echo  class=”vars”>$elementB->getName(),  class=”string”>’ visited by ConcerteVisitor2 <br />’;  
  41.     }  
  42.   
  43. }  
  44.   
  45. /** 
  46.  * 具体因素A 
  47.  */  
  48. class ConcreteElementA  class=”keyword”>implements Element {  
  49.     private class=”vars”>$_name;  
  50.   
  51.     public  class=”keyword”>function __construct( class=”vars”>$name){  
  52.         $this->_name = class=”vars”>$name;  
  53.     }  
  54.   
  55.     public  class=”keyword”>function getName(){  
  56.         return class=”vars”>$this->_name;  
  57.     }  
  58.   
  59.     /** 
  60. class=”comment”>     * 接接受访问问者调用它针对该因素的新格局 
  61.      * @param Visitor $visitor 
  62.      */  
  63.     public  class=”keyword”>function accept(Visitor  class=”vars”>$visitor){  
  64.          class=”vars”>$visitor->visitConcreteElementA( class=”vars”>$this);  
  65.     }  
  66.   
  67. }  
  68.   
  69. /** 
  70.  *  具体因素B 
  71.  */  
  72. class ConcreteElementB  class=”keyword”>implements Element {  
  73.     private class=”vars”>$_name;  
  74.   
  75.     public  class=”keyword”>function __construct( class=”vars”>$name){  
  76.         $this->_name = class=”vars”>$name;  
  77.     }  
  78.   
  79.     public  class=”keyword”>function getName(){  
  80.         return class=”vars”>$this->_name;  
  81.     }  
  82.   
  83.     /** 
  84. class=”comment”>     * 接受访问者调用它针对该因素的新格局 
  85.      * @param Visitor $visitor 
  86.      */  
  87.     public  class=”keyword”>function accept(Visitor  class=”vars”>$visitor){  
  88.          class=”vars”>$visitor->visitConcreteElementB( class=”vars”>$this);  
  89.     }  
  90.   
  91. }  
  92.   
  93. /** 
  94.  * 对象协会 即成分的集合 
  95.  */  
  96. class ObjectStructure {  
  97.     private class=”vars”>$_collection;  
  98.   
  99.     public  class=”keyword”>function __construct(){  
  100.         $this->_collection = class=”keyword”>array();  
  101.     }  
  102.   
  103.   
  104.     public  class=”keyword”>function attach(Element  class=”vars”>$element){  
  105.         returnarray_push( class=”vars”>$this->_collection, class=”vars”>$element);  
  106.     }  
  107.   
  108.     public  class=”keyword”>function detach(Element  class=”vars”>$element){  
  109.         $index= class=”func”>array_search($element, class=”vars”>$this->_collection);  
  110.         if( class=”vars”>$index!==FALSE){  
  111.             unset( class=”vars”>$this->_collection[ class=”vars”>$index]);  
  112.         }  
  113.   
  114.         return class=”vars”>$index;  
  115.     }  
  116.   
  117.     public  class=”keyword”>function accept(Visitor  class=”vars”>$visitor){  
  118.         foreach( class=”vars”>$this->_collection as class=”vars”>$element){  
  119.             $element->accept( class=”vars”>$visitor);  
  120.         }  
  121.     }  
  122. }  
  123.   
  124. class Client {  
  125.   
  126.     /** 
  127.      * Main program. 
  128.      */  
  129.     public  class=”keyword”>static  class=”keyword”>function main(){  
  130.         $elementA =  class=”keyword”>new ConcreteElementA( class=”string”>”ElementA”);  
  131.         $elementB =  class=”keyword”>new ConcreteElementB( class=”string”>”ElementB”);  
  132.         $elementA2 =  class=”keyword”>new ConcreteElementB( class=”string”>”ElementA2″);  
  133.         $visitor1 =  class=”keyword”>new ConcreteVisitor1();  
  134.         $visitor2 =  class=”keyword”>new ConcreteVisitor2();  
  135.   
  136.         $os =  class=”keyword”>new ObjectStructure();  
  137.         $os->attach( class=”vars”>$elementA);  
  138.         $os->attach( class=”vars”>$elementB);  
  139.         $os->attach( class=”vars”>$elementA2);  
  140.         $os->detach( class=”vars”>$elementA);  
  141.         $os->accept( class=”vars”>$visitor1);  
  142.         $os->accept( class=”vars”>$visitor2);  
  143.     }  
  144.   
  145. }  
  146.   
  147. Client::main();  
  148. ?>   
using System;

namespace VisitorPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            ObjectStructure o = new ObjectStructure();
            o.Attach(new Man());
            o.Attach(new Woman());
            //成功时的反应
            Success v1 = new Success();
            o.Display(v1);
            //失败时的反应
            Failing v2 = new Failing();
            o.Display(v2);
            //恋爱时的反应
            Amativenness v3 = new Amativenness();
            o.Display(v3);
            Console.Read();
        }
    }
}

格局适用条件
在偏下情形下能够运用访问者情势:

2个对象组织包蕴众各体系的对象,希望对这个指标实行部分借助其切实项指标操作。在访问者中针对各个具体的品类都提供了2个走访操作,区别品种的指标足以有两样的走访操作。

必要对3个对象组织中的对象举办过多分裂的还要不相干的操作,而要求幸免让那些操作“污染”这么些目的的类,也不希望在增多新操作时修改这个类。访问者方式使得大家得以将有关的拜会操作集中起来定义在访问者类中,对象组织得以被多个不一致的访问者类所使用,将对象自小编与对象的访问操作分离。
 对象协会中目的对应的类很少改变,但常常索要在此指标组织上定义新的操作。

1.概述

【评释与多谢】
正文,站在很多高个儿的肩膀上,借鉴和引用了好多客人拥有版权的文章或撰文,在此,对前人们的贡献致谢。并还要发布引用的剧情、原来的书文者或缘于(一些源于互连网的始末笔者不可能追述本源,深表遗憾)。

using System;

namespace VisitorPattern
{
    class Failing : Action
    {
        public override void GetManConclusion(Man concreateElementA)
        {
            Console.WriteLine("{0}{1}时,闷头喝酒,谁也不用劝。", concreateElementA.GetType().Name, this.GetType().Name);
        }

        public override void GetWomanConclusion(Woman concreateElementB)
        {
            Console.WriteLine("{0}{1}时,眼泪汪汪,谁也劝不了。", concreateElementB.GetType().Name, this.GetType().Name);
        }
    }
}

在下列情况下采纳Vi s i t o r形式:

叁个对象组织包涵很多类对象,它们有两样的接口,而你想对那几个目的实施局地正视于其具体类的操作。

供给对3个对象组织中的对象开始展览过多差异的还要不相干的操作,而你想防止让那个操作“污染”那个指标的类。
Visitor使得你能够将相关的操作集中起来定义在3个类中。当该指标协会被众多运用共享时,用Visitor情势让每一种应用仅包括供给运用的操作。

定义对象协会的类很少改变,但每每索要在此布局上定义新的操作。改变指标协会类必要重定义对具备访问者的接口,那说不定需求相当的大的代价。假若目标组织类平常转移,那么或然依旧在那几个类中定义那么些操作较好。

情势结构
访问者情势涵盖如下剧中人物:
Vistor: 抽象访问者
ConcreteVisitor: 具体访问者
Element: 抽象元素
ConcreteElement: 具体元素
ObjectStructure: 对象组织

Amativenness.cs

8.实现

Element: 抽象元素 Person.cs

【注解与谢谢】
本文,站在众多高个儿的肩头上,借鉴和引用了好多客人拥有版权的小说或撰文,在此,对前人们的进献致谢。并还要发布引用的剧情、原版的书文者或缘于(一些源于网络的始末笔者相当的小概追述本源,深表遗憾)。

3.缓解方案

namespace VisitorPattern
{
    abstract class Action
    {
        //得到男人结论或女人反应
        public abstract void GetManConclusion(Man concreateElementA);
        //得到女人结论或男人反应
        public abstract void GetWomanConclusion(Woman concreateElementB);
    }
}

形式结构
访问者情势涵盖如下剧中人物:
Vistor: 抽象访问者
ConcreteVisitor: 具体访问者
Element: 抽象成分
ConcreteElement: 具体元素
ObjectStructure: 对象协会

7.效果

Woman.cs

using System;

namespace VisitorPattern
{
    //成功
    class Success : Action
    {
        public override void GetManConclusion(Man concreateElementA)
        {
            Console.WriteLine("{0}{1}时,背后多半有一个伟大的女人。", concreateElementA.GetType().Name, this.GetType().Name);
        }

        public override void GetWomanConclusion(Woman concreateElementB)
        {
            Console.WriteLine("{0}{1}时,背后大多有一个不成功的男人。", concreateElementB.GetType().Name, this.GetType().Name);
        }
    }
}

 

形式动机

【参考文献】
《设计形式—可复用面向对象软件的根基》笔者: [美] 埃里克h Gamma / RichardHelm / Ralph Johnson / John Vlissides 译者: 李英军 / 马晓星 / 蔡敏 /
刘建中 等 机械工业出版社
《重构—革新既有代码的筹划》小编: Martin Fowler译者:候捷
中国电力出版社
《敏捷软件开发—原则、形式与实践》小编: 罗伯特 C. 马丁 北大东军事和政院学出版社
《程序员修炼之道—从小工到学者》小编: Andrew Hunt / 戴维 托马斯电子工业出版社
《Head First 设计形式》小编: 弗里曼 译者: O’Reilly Taiwan公司中中原人民共和国电力出版社
《设计方式之禅》 小编: 秦小波 机械工业出版社
MSDN WebCast 《C#面向对象设计情势纵横谈》 助教:李建忠
刘伟(Liu-Wei). 设计方式. 东京:清华东军事和政治高校学出版社, 二〇一一.
刘伟同志. 设计形式实验和培养和陶冶教程. 新加坡:清华出版社, 二零一二.
《大话设计方式》 小编: 程杰 浙大东军事和政院学出版社
《C#图解教程》小编: 索Liss 译者: 苏林 / 朱晔 人民邮政和邮电通讯出版社
《你必须领会的.NET》作者: 王涛
《项目中的.NET》笔者: 李天平 电子工业出版社
《Microsoft .NET集团级应用架构划设想计》笔者: (美)埃斯波西托等撰写 译者:
陈黎夫
http://www.dofactory.com/Patterns/Patterns.aspx .NET Design Patterns
http://www.cnblogs.com/zhenyulu 博客小编:吕震宇
http://www.cnblogs.com/terrylee 博客小编:李会军
http://www.cnblogs.com/anlyren/ 博客作者:anlyren
http://www.cnblogs.com/idior 博客小编:idior
http://www.cnblogs.com/allenlooplee 博客作者:Allen lee
http://blog.csdn.net/ai92 博客小编:ai92
http://www.cnblogs.com/umlonline/ 博客小编:张传波
http://www.cnblogs.com/lovecherry/ 博客作者:LoveCherry 

倾斜的“开闭原则” 

•访问者情势以一种倾斜的不二法门协助“开闭原则”,扩展新的访问者方便,但是扩张新的因素很艰辛。

面向对象的布署性规范中最要紧的正是所谓的”开一闭”原则。二个软件系统的筹划应该尽量做到对扩充开放,对修改关闭。达到这些规则的门道正是服从”对转移的卷入”的规格。这一个条件讲的是在展开软件系统的宏图时,应当设法找出2个软件系统中会变化的部分,将之封装起来。
有的是系统能够服从算法和数据结构分开,相当于说一些指标涵盖算法,而另一对对象涵盖数据,接受算法的操作。要是如此的连串有比较稳定的数据结构,又有易于变化的算法的话,使用访问者方式就是相比较适当的,因为访问者格局使得算法操作的增多变得不难。
扭曲,假诺如此二个系统的数据结构对象易于变动,平常要有新的多寡对象扩张进入的话,就不合乎利用访问者情势。因为在访问者情势中加进新的节点很勤奋,要涉及到在空洞访问者和享有的具体访问者中追加新的点子。

 

namespace VisitorPattern
{
    abstract class Person
    {
        //接受
        public abstract void Accept(Action visitor);
    }
}

Element: 抽象成分 Person.cs

访问者格局:表示一个意义于某指标组织中的各要素的操作。它使您能够在不改变各因素的类的前提下定义作用于这么些成分的新操作。

1)访问者方式中目的组织存款和储蓄了不一致品类的要素对象,以供差别访问者访问。

2)访问者方式包涵八个层次结构,2个是访问者层次结构,提供了思梅止渴访问者和求实访问者,贰个是因素层次结构,提供了聊以自慰成分和现实性因素。

平等的访问者能够以区别的艺术访问分裂的成分,相同的成分得以接受不一样访问者以分化访问格局访问。在访问者形式中,扩展新的访问者无须修改原有系统,系统具备较好的可增加性

Client:客户类

格局实例与分析
夫君和女生—访问者情势示例代码
系统布局
图片 5
Vistor: 抽象访问者  Action.cs

 

 

ConcreteElement: 具体元素 Man.cs

ConcreteElement: 具体成分 Man.cs

方式分析
访问者形式中指标组织存储了分化类别的要素对象,以供分化访问者访问。
访问者格局包含八个层次结构,一个是访问者层次结构,提供了画个饼来解除饥饿访问者和实际访问者,1个是因素层次结构,提供了指雁为羹成分和现实因素。
同等的访问者能够以不相同的措施访问不相同的因素,相同的要素得以承受不一致访问者以不相同访问格局访问。在访问者格局中,扩展新的访问者无须修改原有系统,系统具有较好的可增加性。

using System;

namespace VisitorPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            ObjectStructure o = new ObjectStructure();
            o.Attach(new Man());
            o.Attach(new Woman());
            //成功时的反应
            Success v1 = new Success();
            o.Display(v1);
            //失败时的反应
            Failing v2 = new Failing();
            o.Display(v2);
            //恋爱时的反应
            Amativenness v3 = new Amativenness();
            o.Display(v3);
            Console.Read();
        }
    }
}

相关文章