设计模式之美：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 发布于博客园的系列文章，任何未经作者本人同意的人为或爬虫转载均为耍流氓。