学步园

一、 访问者（Visitor）模式

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

问题提出

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

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

访问者模式

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

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

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

二、 访问者模式的结构

如下图所示，这个静态图显示了有两个具体访问者和两个具体节点的访问者模式的设计，必须指出的是，具体访问者的数目与具体节点的数目没有任何关系，虽然在这个示意性的系统里面两者的数目都是两个。

访问者模式涉及到抽象访问者角色、具体访问者角色、抽象节点角色、具体节点角色、结构对象角色以及客户端角色。

• 抽象访问者（Visitor）角色：声明了一个或者多个访问操作，形成所有的具体元素角色必须实现的接口。
• 具体访问者（ConcreteVisitor）角色：实现抽象访问者角色所声明的接口，也就是抽象访问者所声明的各个访问操作。
• 抽象节点（Node）角色：声明一个接受操作，接受一个访问者对象作为一个参量。
• 具体节点（Node）角色：实现了抽象元素所规定的接受操作。
• 结构对象（ObiectStructure）角色：有如下的一些责任，可以遍历结构中的所有元素；如果需要，提供一个高层次的接口让访问者对象可以访问每一个元素；如果需要，可以设计成一个复合对象或者一个聚集，如列（List）或集合（Set）。

三、 示意性源代码

// Visitor pattern -- Structural example  
using System;
using System.Collections;

// "Visitor"
abstract class Visitor
{
  // Methods
  abstract public void VisitConcreteElementA(
    ConcreteElementA concreteElementA );
  abstract public void VisitConcreteElementB(
    ConcreteElementB concreteElementB );
}

// "ConcreteVisitor1"
class ConcreteVisitor1 : Visitor
{
  // Methods
  override public void VisitConcreteElementA(
    ConcreteElementA concreteElementA )
  {
    Console.WriteLine( "{0} visited by {1}",
      concreteElementA, this );
  }

  override public void VisitConcreteElementB(
    ConcreteElementB concreteElementB )
  {
    Console.WriteLine( "{0} visited by {1}",
      concreteElementB, this );
  }
}

// "ConcreteVisitor2"
class ConcreteVisitor2 : Visitor
{
  // Methods
  override public void VisitConcreteElementA(
    ConcreteElementA concreteElementA )
  {
    Console.WriteLine( "{0} visited by {1}",
      concreteElementA, this );
  }
  override public void VisitConcreteElementB(
    ConcreteElementB concreteElementB )
  {
    Console.WriteLine( "{0} visited by {1}",
      concreteElementB, this );
  }
}

// "Element"
abstract class Element
{
  // Methods
  abstract public void Accept( Visitor visitor );
}

// "ConcreteElementA"
class ConcreteElementA : Element
{
  // Methods
  override public 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被访问的过程是一样的。

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

四、 一个实际应用Visitor模式的例子

以下的例子演示了Employee对象集合允许被不同的Visitor（IncomeVisitor与VacationVisitor）访问其中的内容。

// Visitor pattern -- Real World example  
using System;
using System.Collections;

// "Visitor"
abstract class Visitor
{
  // Methods
  abstract public void Visit( Element element );
}

// "ConcreteVisitor1"
class IncomeVisitor : Visitor
{
  // Methods
  public override void Visit( Element element )
  {
    Employee employee = ((Employee)element);
 
    // Provide 10% pay raise
    employee.Income *= 1.10;
    Console.WriteLine( "{0}'s new income: {1:C}",
      employee.Name, employee.Income );
  }
}

// "ConcreteVisitor2"
class VacationVisitor : Visitor
{
  public override void Visit( Element element )
  {
    Employee employee = ((Employee)element);

    // Provide 3 extra vacation days
    employee.VacationDays += 3;
    Console.WriteLine( "{0}'s new vacation days: {1}",
      employee.Name, employee.VacationDays );
  }
}

// "Element"
abstract class Element