苏飞论坛

 找回密码
 马上注册

QQ登录

只需一步,快速开始

扫一扫,访问微社区

分布式系统框架(V2.0) 轻松承载百亿数据,千万流量!讨论专区 - 源码下载 - 官方教程

HttpHelper万能框架(V2.3-含.netcore) HttpHelper官方出品,无敌框架讨论区 - 源码下载 - 在线测试和代码生成

HttpHelper爬虫类(V2.0) 最牛的爬虫类,没有爬不到只有想不到 源码 - 代码生成器 - 讨论区 - 教程- 例子

查看: 746|回复: 4

[学习心得] C#访问者模式介绍

[复制链接]
发表于 2019-1-14 14:53:17 | 显示全部楼层 |阅读模式
本帖最后由 惜 于 2019-1-14 14:58 编辑

一 、  访问者 (Visitor ) 模式

      访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话,接受这个操作
的数据结构则可以保持不变。

问题提出

      System.Collection 命名空间下提供了大量集合操作对象。但大多数情况下处理的都是同类对象的聚集。换言
之,在聚集上采取的操作都是一些针对同类型对象的同类操作。但是如果针对一个保存有不同类型对象的聚集采
取某种操作该怎么办呢?

      粗看上去,这似乎不是什么难题。可是如果需要针对一个包含不同类型元素的聚集采取某种操作,而操作的细节
根据元素的类型不同而有所不同时,就会出现必须对元素类型做类型判断的条件转移语句。这个时候,使用访问
者模式就是一个值得考虑的解决方案。

访问者模式

      访问者模式适用于数据结构相对未定的系统,它把数据结构和作用于结构上的操作之间的耦合解脱开,使得操作
集合可以相对自由地演化。

      数据结构的每一个节点都可以接受一个访问者的调用,此节点向访问者对象传入节点对象,而访问者对象则反过
来执行节点对象的操作。这样的过程叫做"双重分派"。节点调用访问者,将它自己传入,访问者则将某算法针对
此节点执行。

双重分派意味着施加于节点之上的操作是基于访问者和节点本身的数据类型,而不仅仅是其中的一者。

二 、  访问者模式的结构

      如下图所示,这个静态图显示了有两个具体访问者和两个具体节点的访问者模式的设计,必须指出的是,具体访
问者的数目与具体节点的数目没有任何关系,虽然在这个示意性的系统里面两者的数目都是两个。
1.png
访问者模式涉及到抽象访问者角色、具体访问者角色、抽象节点角色、具体节点角色、结构对象角色以及客户端角色。

 抽象访问者(Visitor)角色:声明了一个或者多个访问操作,形成所有的具体元素角色必须实现的接口。

 具体访问者(ConcreteVisitor)角色:实现抽象访问者角色所声明的接口,也就是抽象访问者所声明的各个访问操作。

 抽象节点(Node)角色:声明一个接受操作,接受一个访问者对象作为一个参量。

 具体节点(Node)角色:实现了抽象元素所规定的接受操作。

 结构对象(ObiectStructure)角色:有如下的一些责任,可以遍历结构中的所有元素;如果需要,提供一个高层次的接口让访问者对象可以访问
每一个元素;如果需要,可以设计成一个复合对象或者一个聚集,如列(List)或集合(Set)。

三 、  示意性源代码
[C#] 纯文本查看 复制代码
// Visitor pattern -- Structural example
using System;
using System.Collections;
// "Visitor"
abstract class Visitor
{
    // Methods
    public abstract void VisitConcreteElementA(
    ConcreteElementA concreteElementA);
    public abstract void VisitConcreteElementB(
    ConcreteElementB concreteElementB);
}
// "ConcreteVisitor1"
class ConcreteVisitor1 : Visitor
{
    // Methods
    public override void VisitConcreteElementA(
    ConcreteElementA concreteElementA)
    {
        Console.WriteLine("{0} visited by {1}",
        concreteElementA, this);
    }
    public override void VisitConcreteElementB(
    ConcreteElementB concreteElementB)
    {
        Console.WriteLine("{0} visited by {1}",
        concreteElementB, this);
    }
}
// "ConcreteVisitor2"
class ConcreteVisitor2 : Visitor
{
    // Methods
    public override void VisitConcreteElementA(
    ConcreteElementA concreteElementA)
    {
        Console.WriteLine("{0} visited by {1}",
        concreteElementA, this);
    }
    public override void VisitConcreteElementB(
    ConcreteElementB concreteElementB)
    {
        Console.WriteLine("{0} visited by {1}",
        concreteElementB, this);
    }
}
// "Element"
abstract class Element
{
    // Methods
    public abstract void Accept(Visitor visitor);
}
// "ConcreteElementA"
class ConcreteElementA : Element
{
    // Methods
    public override void Accept(Visitor visitor)
    {
        visitor.VisitConcreteElementA(this);
    }
    public void OperationA()
    {
    }
}
// "ConcreteElementB"
class ConcreteElementB : Element
{
    // Methods
    override public void Accept(Visitor visitor)
    {
        visitor.VisitConcreteElementB(this);
    }
    public void OperationB()
    {
    }
}
// "ObjectStructure"
class ObjectStructure
{
    // Fields
    private ArrayList elements = new ArrayList();
    // Methods
    public void Attach(Element element)
    {
        elements.Add(element);
    }
    public void Detach(Element element)
    {
        elements.Remove(element);
    }
    public void Accept(Visitor visitor)
    {
        foreach (Element e in elements)
            e.Accept(visitor);
    }
}
/// <summary>
/// Client test
/// </summary>
public class Client
{
    public static void Main(string[] args)
    {
        // Setup structure
        ObjectStructure o = new ObjectStructure();
        o.Attach(new ConcreteElementA());
        o.Attach(new ConcreteElementB());
        // Create visitor objects
        ConcreteVisitor1 v1 = new ConcreteVisitor1();
        ConcreteVisitor2 v2 = new ConcreteVisitor2();
        // Structure accepting visitors
        o.Accept(v1);
        o.Accept(v2);
    }
}


结构对象会遍历它自己所保存的聚集中的所有节点,在本系统中就是节点 ConcreteElementA 和节点
ConcreteElementB。首先 ConcreteElementA 会被访问到,这个访问是由以下的操作组成的:

1. ConcreteElementA 对象的接受方法被调用,并将 VisitorA 对象本身传入;
2. ConcreteElementA 对象反过来调用 VisitorA 对象的访问方法,并将ConcreteElementA 对象本身传入;
3. VisitorA对象调用ConcreteElementA对象的商业方法operationA( )。

从而就完成了双重分派过程,接着,ConcreteElementB 会被访问,这个访问的过程和 ConcreteElementA
被访问的过程是一样的。

因此,结构对象对聚集元素的遍历过程就是对聚集中所有的节点进行委派的过程,也就是双重分派的过程。换言
之,系统有多少个节点就会发生多少个双重分派过程。



发表于 2019-1-14 15:12:23 | 显示全部楼层
发表于 2019-1-14 15:36:07 | 显示全部楼层
发表于 2019-1-14 19:48:30 | 显示全部楼层
发表于 2019-1-14 20:57:43 | 显示全部楼层
您需要登录后才可以回帖 登录 | 马上注册

本版积分规则

QQ|手机版|小黑屋|手机版|联系我们|关于我们|广告合作|苏飞论坛 ( 豫ICP备17001017号-1)

GMT+8, 2019-12-7 23:07

© 2017-2018

快速回复 返回顶部 返回列表