一、 訪問者（Visitor）模式

訪問者模式的目的是封裝一些施加于某種數(shù)據(jù)結(jié)構(gòu)元素之上的操作。一旦這些操作需要修改的話，接受這個(gè)操作的數(shù)據(jù)結(jié)構(gòu)則可以保持不變。

問題提出

System.Collection命名空間下提供了大量集合操作對(duì)象。但大多數(shù)情況下處理的都是同類對(duì)象的聚集。換言之，在聚集上采取的操作都是一些針對(duì)同類型對(duì)象的同類操作。但是如果針對(duì)一個(gè)保存有不同類型對(duì)象的聚集采取某種操作該怎么辦呢？

粗看上去，這似乎不是什么難題?？墒侨绻枰槍?duì)一個(gè)包含不同類型元素的聚集采取某種操作，而操作的細(xì)節(jié)根據(jù)元素的類型不同而有所不同時(shí)，就會(huì)出現(xiàn)必須對(duì)元素類型做類型判斷的條件轉(zhuǎn)移語(yǔ)句。這個(gè)時(shí)候，使用訪問者模式就是一個(gè)值得考慮的解決方案。

訪問者模式

訪問者模式適用于數(shù)據(jù)結(jié)構(gòu)相對(duì)未定的系統(tǒng)，它把數(shù)據(jù)結(jié)構(gòu)和作用于結(jié)構(gòu)上的操作之間的耦合解脫開，使得操作集合可以相對(duì)自由地演化。

數(shù)據(jù)結(jié)構(gòu)的每一個(gè)節(jié)點(diǎn)都可以接受一個(gè)訪問者的調(diào)用，此節(jié)點(diǎn)向訪問者對(duì)象傳入節(jié)點(diǎn)對(duì)象，而訪問者對(duì)象則反過來(lái)執(zhí)行節(jié)點(diǎn)對(duì)象的操作。這樣的過程叫做"雙重分派"。節(jié)點(diǎn)調(diào)用訪問者，將它自己傳入，訪問者則將某算法針對(duì)此節(jié)點(diǎn)執(zhí)行。

雙重分派意味著施加于節(jié)點(diǎn)之上的操作是基于訪問者和節(jié)點(diǎn)本身的數(shù)據(jù)類型，而不僅僅是其中的一者。

二、 訪問者模式的結(jié)構(gòu)

如下圖所示，這個(gè)靜態(tài)圖顯示了有兩個(gè)具體訪問者和兩個(gè)具體節(jié)點(diǎn)的訪問者模式的設(shè)計(jì)，必須指出的是，具體訪問者的數(shù)目與具體節(jié)點(diǎn)的數(shù)目沒有任何關(guān)系，雖然在這個(gè)示意性的系統(tǒng)里面兩者的數(shù)目都是兩個(gè)。

訪問者模式涉及到抽象訪問者角色、具體訪問者角色、抽象節(jié)點(diǎn)角色、具體節(jié)點(diǎn)角色、結(jié)構(gòu)對(duì)象角色以及客戶端角色。

• 抽象訪問者（Visitor）角色：聲明了一個(gè)或者多個(gè)訪問操作，形成所有的具體元素角色必須實(shí)現(xiàn)的接口。
• 具體訪問者（ConcreteVisitor）角色：實(shí)現(xiàn)抽象訪問者角色所聲明的接口，也就是抽象訪問者所聲明的各個(gè)訪問操作。
• 抽象節(jié)點(diǎn)（Node）角色：聲明一個(gè)接受操作，接受一個(gè)訪問者對(duì)象作為一個(gè)參量。
• 具體節(jié)點(diǎn)（Node）角色：實(shí)現(xiàn)了抽象元素所規(guī)定的接受操作。
• 結(jié)構(gòu)對(duì)象（ObiectStructure）角色：有如下的一些責(zé)任，可以遍歷結(jié)構(gòu)中的所有元素；如果需要，提供一個(gè)高層次的接口讓訪問者對(duì)象可以訪問每一個(gè)元素；如果需要，可以設(shè)計(jì)成一個(gè)復(fù)合對(duì)象或者一個(gè)聚集，如列（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 );
  }
}

/// 

/// Client test
/// 
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 );
  }
}

結(jié)構(gòu)對(duì)象會(huì)遍歷它自己所保存的聚集中的所有節(jié)點(diǎn)，在本系統(tǒng)中就是節(jié)點(diǎn)ConcreteElementA和節(jié)點(diǎn)ConcreteElementB。首先ConcreteElementA會(huì)被訪問到，這個(gè)訪問是由以下的操作組成的：

1. ConcreteElementA對(duì)象的接受方法被調(diào)用，并將VisitorA對(duì)象本身傳入；
2. ConcreteElementA對(duì)象反過來(lái)調(diào)用VisitorA對(duì)象的訪問方法，并將ConcreteElementA對(duì)象本身傳入；
3. VisitorA對(duì)象調(diào)用ConcreteElementA對(duì)象的商業(yè)方法operationA( )。

從而就完成了雙重分派過程，接著，ConcreteElementB會(huì)被訪問，這個(gè)訪問的過程和ConcreteElementA被訪問的過程是一樣的。

因此，結(jié)構(gòu)對(duì)象對(duì)聚集元素的遍歷過程就是對(duì)聚集中所有的節(jié)點(diǎn)進(jìn)行委派的過程，也就是雙重分派的過程。換言之，系統(tǒng)有多少個(gè)節(jié)點(diǎn)就會(huì)發(fā)生多少個(gè)雙重分派過程。

四、 一個(gè)實(shí)際應(yīng)用Visitor模式的例子

以下的例子演示了Employee對(duì)象集合允許被不同的Visitor（IncomeVisitor與VacationVisitor）訪問其中的內(nèi)容。

// 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
{
  // Methods
  abstract public void Accept( Visitor visitor );
}

// "ConcreteElement"
class Employee : Element
{
  // Fields
  string name;
  double income;
  int vacationDays;

  // Constructors
  public Employee( string name, double income,
    int vacationDays )
  {
    this.name = name;
    this.income = income;
    this.vacationDays = vacationDays;
  }

  // Properties
  public string Name
  {
    get{ return name; }
    set{ name = value; }
  }

  public double Income
  {
    get{ return income; }
    set{ income = value; }
  }

  public int VacationDays
  {
    get{ return vacationDays; }
    set{ vacationDays = value; }
  }

  // Methods
  public override void Accept( Visitor visitor )
  {
    visitor.Visit( this );
  }
}

// "ObjectStructure"
class Employees
{
  // Fields
  private ArrayList employees = new ArrayList();

  // Methods
  public void Attach( Employee employee )
  {
    employees.Add( employee );
  }

  public void Detach( Employee employee )
  {
    employees.Remove( employee );
  }

  public void Accept( Visitor visitor )
  {
    foreach( Employee e in employees )
      e.Accept( visitor );
  }
}

/// 

/// VisitorApp test
/// 
public class VisitorApp
{
  public static void Main( string[] args )
  {
    // Setup employee collection
    Employees e = new Employees();
    e.Attach( new Employee( "Hank", 25000.0, 14 ) );
    e.Attach( new Employee( "Elly", 35000.0, 16 ) );
    e.Attach( new Employee( "Dick", 45000.0, 21 ) );

    // Create two visitors
    IncomeVisitor v1 = new IncomeVisitor();
    VacationVisitor v2 = new VacationVisitor();

    // Employees are visited
    e.Accept( v1 );
    e.Accept( v2 );
  }
}

五、 在什么情況下應(yīng)當(dāng)使用訪問者模式

有意思的是，在很多情況下不使用設(shè)計(jì)模式反而會(huì)得到一個(gè)較好的設(shè)計(jì)。換言之，每一個(gè)設(shè)計(jì)模式都有其不應(yīng)當(dāng)使用的情況。訪問者模式也有其不應(yīng)當(dāng)使用的情況，讓我們
先看一看訪問者模式不應(yīng)當(dāng)在什么情況下使用。

傾斜的可擴(kuò)展性

訪問者模式僅應(yīng)當(dāng)在被訪問的類結(jié)構(gòu)非常穩(wěn)定的情況下使用。換言之，系統(tǒng)很少出現(xiàn)需要加入新節(jié)點(diǎn)的情況。如果出現(xiàn)需要加入新節(jié)點(diǎn)的情況，那么就必須在每一個(gè)訪問對(duì)象里加入一個(gè)對(duì)應(yīng)于這個(gè)新節(jié)點(diǎn)的訪問操作，而這是對(duì)一個(gè)系統(tǒng)的大規(guī)模修改，因而是違背"開一閉"原則的。

訪問者模式允許在節(jié)點(diǎn)中加入新的方法，相應(yīng)的僅僅需要在一個(gè)新的訪問者類中加入此方法，而不需要在每一個(gè)訪問者類中都加入此方法。

顯然，訪問者模式提供了傾斜的可擴(kuò)展性設(shè)計(jì)：方法集合的可擴(kuò)展性和類集合的不可擴(kuò)展性。換言之，如果系統(tǒng)的數(shù)據(jù)結(jié)構(gòu)是頻繁變化的，則不適合使用訪問者模式。

"開一閉"原則和對(duì)變化的封裝

面向?qū)ο蟮脑O(shè)計(jì)原則中最重要的便是所謂的"開一閉"原則。一個(gè)軟件系統(tǒng)的設(shè)計(jì)應(yīng)當(dāng)盡量做到對(duì)擴(kuò)展開放，對(duì)修改關(guān)閉。達(dá)到這個(gè)原則的途徑就是遵循"對(duì)變化的封裝"的原則。這個(gè)原則講的是在進(jìn)行軟件系統(tǒng)的設(shè)計(jì)時(shí)，應(yīng)當(dāng)設(shè)法找出一個(gè)軟件系統(tǒng)中會(huì)變化的部分，將之封裝起來(lái)。

很多系統(tǒng)可以按照算法和數(shù)據(jù)結(jié)構(gòu)分開，也就是說(shuō)一些對(duì)象含有算法，而另一些對(duì)象含有數(shù)據(jù)，接受算法的操作。如果這樣的系統(tǒng)有比較穩(wěn)定的數(shù)據(jù)結(jié)構(gòu)，又有易于變化的算法的話，使用訪問者模式就是比較合適的，因?yàn)樵L問者模式使得算法操作的增加變得容易。

反過來(lái)，如果這樣一個(gè)系統(tǒng)的數(shù)據(jù)結(jié)構(gòu)對(duì)象易于變化，經(jīng)常要有新的數(shù)據(jù)對(duì)象增加進(jìn)來(lái)的話，就不適合使用訪問者模式。因?yàn)樵谠L問者模式中增加新的節(jié)點(diǎn)很困難，要涉及到在抽象訪問者和所有的具體訪問者中增加新的方法。

六、 使用訪問者模式的優(yōu)點(diǎn)和缺點(diǎn)

訪問者模式有如下的優(yōu)點(diǎn)：

1. 訪問者模式使得增加新的操作變得很容易。如果一些操作依賴于一個(gè)復(fù)雜的結(jié)構(gòu)對(duì)象的話，那么一般而言，增加新的操作會(huì)很復(fù)雜。而使用訪問者模式，增加新的操作就意味著增加一個(gè)新的訪問者類，因此，變得很容易。
2. 訪問者模式將有關(guān)的行為集中到一個(gè)訪問者對(duì)象中，而不是分散到一個(gè)個(gè)的節(jié)點(diǎn)類中。
3. 訪問者模式可以跨過幾個(gè)類的等級(jí)結(jié)構(gòu)訪問屬于不同的等級(jí)結(jié)構(gòu)的成員類。迭代子只能訪問屬于同一個(gè)類型等級(jí)結(jié)構(gòu)的成員對(duì)象，而不能訪問屬于不同等級(jí)結(jié)構(gòu)的對(duì)象。訪問者模式可以做到這一點(diǎn)。
4. 積累狀態(tài)。每一個(gè)單獨(dú)的訪問者對(duì)象都集中了相關(guān)的行為，從而也就可以在訪問的過程中將執(zhí)行操作的狀態(tài)積累在自己內(nèi)部，而不是分散到很多的節(jié)點(diǎn)對(duì)象中。這是有益于系統(tǒng)維護(hù)的優(yōu)點(diǎn)。

訪問者模式有如下的缺點(diǎn)：

1. 增加新的節(jié)點(diǎn)類變得很困難。每增加一個(gè)新的節(jié)點(diǎn)都意味著要在抽象訪問者角色中增加一個(gè)新的抽象操作，并在每一個(gè)具體訪問者類中增加相應(yīng)的具體操作。
2. 破壞封裝。訪問者模式要求訪問者對(duì)象訪問并調(diào)用每一個(gè)節(jié)點(diǎn)對(duì)象的操作，這隱含了一個(gè)對(duì)所有節(jié)點(diǎn)對(duì)象的要求：它們必須暴露一些自己的操作 和內(nèi)部狀態(tài)。不然，訪問者的訪問就變得沒有意義。由于訪問者對(duì)象自己會(huì)積累訪問操作所需的狀態(tài)，從而使這些狀態(tài)不再存儲(chǔ)在節(jié)點(diǎn)對(duì)象中，這也是破壞封裝的。