設計模式之美：Visitor（訪問者）

索引

• 意圖
• 結構
• 參與者
• 適用性
• 效果
• 相關模式
• 實現
  • 實現方式（一）：Visitor 模式結構樣式代碼。
  • 實現方式（二）：使用 Visitor 模式解構設計。
  • 實現方式（三）：使用 Acyclic Visitor 模式解構設計。

意圖

表示一個作用於某對象結構中的各元素的操作。

Visitor 使你可以在不改變各元素的類的前提下定義作用於這些元素的新操作。

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.

結構

參與者

Visitor

• 為該對象結構中 ConcreteElement 的每一個類聲明一個 Visit 操作。該操作的名字和特征標識了發送 Visit 請求給該訪問者的那個類。

ConcreteVisitor

• 實現每個由 Visitor 聲明的操作。

Element

• 定義一個 Accept 操作，它以一個 Visitor 為參數。

ConcreteElement

• 實現 Accept 操作，該操作以一個 Visitor 為參數。

ObjectStructure

• 能枚舉 Element。
• 可以提供一個高層的接口以允許該 Visitor 訪問它的元素。
• 可以是一個 Composite 或是一個集合、列表或無序集合。

適用性

在以下情況下可以使用 Visitor 模式：

• 一個對象結構包含很多類操作，它們有不同的接口，而你想對這些對象實施一些依賴於其具體類的操作。
• 需要對一個對象結構中的對象進行很多不同的並且不相關的操作，而你想避免讓這些操作污染這些對象的類。
• 定義對象結構的類很少改變，但經常需要在此結構上定義新的操作。

缺點

• 增加新的 ConcreteElement 類很困難。添加新的 ConcreteElement 都要在 Visitor 中添加一個新的抽象操作。
• 可能破壞封裝。Visitor 假定 ConcreteElement 接口的功能足夠強，足以讓 Visitor 進行它的工作。但有時會迫使你提供 ConcreteElement 的內部狀態的公共操作。

效果

• Visitor 模式使得易於增加新的操作。
• Visitor 集中相關的操作而分離無關的操作。

相關模式

• Visitor 可以用於對一個 Composite 模式定義的對象結構進行操作。
• Visitor 可以用於 Interpreter 解釋。

實現

實現方式（一）：Visitor 模式結構樣式代碼。

namespace VisitorPattern.Implementation1
{
  public abstract class Element
  {
    public abstract void Accept(Visitor visitor);
  }

  public abstract class Visitor
  {
    public abstract void Visit(ConcreteElementA element);
    public abstract void Visit(ConcreteElementB element);
  }

  public class ObjectStructure
  {
    private List<Element> _elements = new List<Element>();

    public void Attach(Element element)
    {
      _elements.Add(element);
    }

    public void Detach(Element element)
    {
      _elements.Remove(element);
    }

    public void Accept(Visitor visitor)
    {
      foreach (var element in _elements)
      {
        element.Accept(visitor);
      }
    }
  }

  public class ConcreteElementA : Element
  {
    public string Name { get; set; }

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

  public class ConcreteElementB : Element
  {
    public string ID { get; set; }

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

  public class ConcreteVisitorA : Visitor
  {
    public override void Visit(ConcreteElementA element)
    {
      Console.WriteLine(
        "ConcreteVisitorA visited ConcreteElementA : {0}", 
        element.Name);
    }

    public override void Visit(ConcreteElementB element)
    {
      Console.WriteLine(
        "ConcreteVisitorA visited ConcreteElementB : {0}", 
        element.ID);
    }
  }

  public class ConcreteVisitorB : Visitor
  {
    public override void Visit(ConcreteElementA element)
    {
      Console.WriteLine(
        "ConcreteVisitorB visited ConcreteElementA : {0}", 
        element.Name);
    }

    public override void Visit(ConcreteElementB element)
    {
      Console.WriteLine(
        "ConcreteVisitorB visited ConcreteElementB : {0}", 
        element.ID);
    }
  }

  public class Client
  {
    public void TestCase1()
    {
      var objectStructure = new ObjectStructure();

      objectStructure.Attach(new ConcreteElementA());
      objectStructure.Attach(new ConcreteElementB());

      objectStructure.Accept(new ConcreteVisitorA());
      objectStructure.Accept(new ConcreteVisitorB());
    }
  }
}

實現方式（二）：使用 Visitor 模式解構設計。

假設我們有一個 Employee 類，Employee 分為按時薪計算的 Employee 和按月薪計算的 Employee。

  public class Employee
  {
    public abstract string GetHoursAndPayReport();
  }

  public class HourlyEmployee : Employee
  {
    public override string GetHoursAndPayReport()
    {
      // generate the line for this hourly employee
      return "100 Hours and $1000 in total.";
    }
  }

  public class SalariedEmployee : Employee
  {
    public override string GetHoursAndPayReport()
    {
      // do nothing
      return string.Empty;
    }
  }

這段代碼的問題是，Employee 類及子類耦合了 Salary Report 相關的職責，這侵犯了單一職責原則（Single Responsibility Principle），因為其導致每次需要更改 Report 相關的職責時，都需要修改 Employee 類。

我們是用 Visitor 模式來解決這個問題。

namespace VisitorPattern.Implementation2
{
  public abstract class Employee
  {
    public abstract string Accept(EmployeeVisitor visitor);
  }

  public class HourlyEmployee : Employee
  {
    public override string Accept(EmployeeVisitor visitor)
    {
      return visitor.Visit(this);
    }
  }

  public class SalariedEmployee : Employee
  {
    public override string Accept(EmployeeVisitor visitor)
    {
      return visitor.Visit(this);
    }
  }

  public abstract class EmployeeVisitor
  {
    public abstract string Visit(HourlyEmployee employee);
    public abstract string Visit(SalariedEmployee employee);
  }

  public class HoursPayReport : EmployeeVisitor
  {
    public override string Visit(HourlyEmployee employee)
    {
      // generate the line of the report.
      return "100 Hours and $1000 in total.";
    }

    public override string Visit(SalariedEmployee employee)
    {
      // do nothing
      return string.Empty;
    }
  }
}

實現方式（三）：使用 Acyclic Visitor 模式解構設計。

我們注意到 Employee 類依賴於 EmployeeVisitor 基類。而 EmployeeVisitor 類為每個 Employee 的子類都提供了一個 Visit 方法。

因此，這里形成了一個依賴關系的環。這導致 Visitor 在響應變化時變得復雜。

Visitor 模式在類繼承關系不是經常變化時可以工作的很好，但在子類衍生頻繁的情況下會增加復雜度。

此時，我們可以應用 Acyclic Visitor 模式，抽象出窄接口，以使 Employee 子類僅依賴於該窄接口。

namespace VisitorPattern.Implementation3
{
  public abstract class Employee
  {
    public abstract string Accept(EmployeeVisitor visitor);
  }

  public class HourlyEmployee : Employee
  {
    public override string Accept(EmployeeVisitor visitor)
    {
      try
      {
        IHourlyEmployeeVisitor hourlyEmployeeVisitor = (IHourlyEmployeeVisitor)visitor;
        return hourlyEmployeeVisitor.Visit(this);
      }
      catch (InvalidCastException ex)
      {
        Console.WriteLine(ex.Message);
      }

      return string.Empty;
    }
  }

  public class SalariedEmployee : Employee
  {
    public override string Accept(EmployeeVisitor visitor)
    {
      try
      {
        ISalariedEmployeeVisitor salariedEmployeeVisitor = (ISalariedEmployeeVisitor)visitor;
        return salariedEmployeeVisitor.Visit(this);
      }
      catch (InvalidCastException ex)
      {
        Console.WriteLine(ex.Message);
      }

      return string.Empty;
    }
  }

  public interface IHourlyEmployeeVisitor
  {
    string Visit(HourlyEmployee employee);
  }

  public interface ISalariedEmployeeVisitor
  {
    string Visit(SalariedEmployee employee);
  }

  public abstract class EmployeeVisitor
  {
  }

  public class HoursPayReport : EmployeeVisitor, IHourlyEmployeeVisitor
  {
    public string Visit(HourlyEmployee employee)
    {
      // generate the line of the report.
      return "100 Hours and $1000 in total.";
    }
  }

  public class SalariedPayReport : EmployeeVisitor, ISalariedEmployeeVisitor
  {
    public string Visit(SalariedEmployee employee)
    {
      return "Something";
    }
  }
}

參考文章

• I Use Visitor
• Visitor
• 無環的visitor模式

《設計模式之美》為 Dennis Gao 發布於博客園的系列文章，任何未經作者本人同意的人為或爬蟲轉載均為耍流氓。