Visitor
访问者模式：将用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。核心就是 将数据的操作与数据结构进行分离。
访问者描述的场景就是：一个对象中有多种不同的元素，不同的操作者对于相同的对象会拥有不同的操作，也就是不同的操作对象对于相同元素的关注点不同。比如

  • 当我们到饭店点某个菜的时候， 顾客关心的是这个菜好不好吃，老板的关心的是这个菜能赚多少钱，厨师关心的是这个菜怎么做以及怎么做得好吃。
  • 一辆新车上市以后， 对于购买者而言关心的是该车的性价比，对于销售来说是如何才能卖出去，对于汽车厂商来说或许就是怎么才能让这辆车卖得好而且口碑好。
  • 曾经白岩松说的外星人掉落到各省的反应： 浙江人会想到怎么做成外星人模型，北京人会想到怎么去接待，广东人会想到怎么吃等等

上面的例子中来说， 对于一个操作对象，不同的角色有不同的关注点或者反应。 这就是访问者设计模式的应用场景。
UML图如下：
3-1Q11910135Y25.gif

  • 抽象访问者（Visitor）角色：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识了被访问的具体元素。
  • 具体访问者（ConcreteVisitor）角色：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。
  • 抽象元素（Element）角色：声明一个包含接受操作 accept() 的接口，被接受的访问者对象作为 accept() 方法的参数。
  • 具体元素（ConcreteElement）角色：实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作。
  • 对象结构（Object Structure）角色：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法，通常由 List、Set、Map 等聚合类实现。

上面的类图比较复杂，访问者模式也被称为最难的设计模式 ，我理解的访问者模式的实现就是：访问者来访问我的元素，然后元素把自己交给访问者带走， 访问者带着元素回到自己家做自己的操作。

1、场景描述

我们这里就以白岩松调侃各地对外星人的反应的例子， 用访问者模式来实现。

2、实现

  1. /// <summary>
  2. /// 抽象元素类
  3. /// </summary>
  4. public interface IElement
  5. {
  6.     /// <summary>
  7.     /// 接受具体的访问者
  8.     /// </summary>
  9.     /// <param name="visitor"></param>
  10.     void Accept(IVisitor visitor);
  11. }
  12. /// <summary>
  13. /// 具体元素类 -- 外星人
  14. /// </summary>
  15. public class AlienElement : IElement
  16. {
  17.     /// <summary>
  18.     /// 接受具体访问者
  19.     /// </summary>
  20.     /// <param name="visitor"></param>
  21.     public void Accept(IVisitor visitor)
  22.     {
  23.         visitor.Visit(this);
  24.     }
  26.     /// <summary>
  27.     /// 这里可以添加该具体元素自己的方法
  28.     /// </summary>
  29.     public void Operation()
  30.     {
  31.         Console.WriteLine("外星人掉落了...");
  32.     }
  33. }
  34. /// <summary>
  35. /// 抽象访问者
  36. /// </summary>
  37. public interface IVisitor
  38. {
  39.     /// <summary>
  40.     /// 接收具体元素类调用，传入具体元素进行不同访问者的不同操作
  41.     /// </summary>
  42.     /// <param name="element"></param>
  43.     void Visit(AlienElement element);
  44. }
  45. /// <summary>
  46. /// 具体访问者 -- 北京
  47. /// </summary>
  48. public class BeiJingVisitor : IVisitor
  49. {
  50.     /// <summary>
  51.     /// 具体访问者对具体元素的操作逻辑
  52.     /// </summary>
  53.     /// <param name="element"></param>
  54.     public void Visit(AlienElement element)
  55.     {
  56.         element.Operation();
  57.         Console.WriteLine("这里是北京，我们在考虑怎么去接待它");
  58.     }
  59. }
  60. /// <summary>
  61. /// 具体访问者 -- 广东
  62. /// </summary>
  63. public class GuangDongVisitor : IVisitor
  64. {
  65.     /// <summary>
  66.     /// 具体访问者对具体元素的操作逻辑
  67.     /// </summary>
  68.     /// <param name="element"></param>
  69.     public void Visit(AlienElement element)
  70.     {
  71.         element.Operation();
  72.         Console.WriteLine("这里是广东，我们正在想这玩意怎么吃");
  73.     }
  74. }
  75. /// <summary>
  76. /// 具体访问者--浙江
  77. /// </summary>
  78. public class ZheJiangVisitor : IVisitor
  79. {
  80.     /// <summary>
  81.     /// 具体访问者对具体元素的操作逻辑
  82.     /// </summary>
  83.     /// <param name="element"></param>
  84.     /// <exception cref="NotImplementedException"></exception>
  85.     public void Visit(AlienElement element)
  86.     {
  87.         element.Operation();
  88.         Console.WriteLine("这里是浙江义乌，我们正在考虑如何做一个相同的模型");
  89.     }
  90. }
  91. /// <summary>
  92. /// 对象结构角色 -- 外星文明 
  93. /// </summary>
  94. public class Extracivilization
  95. {
  96.     private List<IElement> elements = new();
  97.     /// <summary>
  98.     /// 添加具体元素
  99.     /// </summary>
  100.     public void AddElement(IElement element) 
  101.     {
  102.         elements.Add(element);
  103.     }
  104.     /// <summary>
  105.     /// 移除具体元素
  106.     /// </summary>
  107.     /// <param name="element"></param>
  108.     public void RemoveElement(IElement element)
  109.     {
  110.         elements.Remove(element);
  111.     }
  112.     /// <summary>
  113.     /// 接受访问者对具体元素进行访问
  114.     /// </summary>
  115.     /// <param name="visitor"></param>
  116.     public void Accept(IVisitor visitor)
  117.     {
  118.         elements.ForEach(it => it.Accept(visitor));
  119.     }
  120. }
  122. // 客户端访问
  123. Extracivilization extracivilization = new Extracivilization();
  124. extracivilization.AddElement(new AlienElement());
  125. extracivilization.Accept(new BeiJingVisitor());
  126. Console.WriteLine("*********************************");
  127. extracivilization.Accept(new ZheJiangVisitor());
  128. Console.WriteLine("*********************************");
  129. extracivilization.Accept(new GuangDongVisitor());

执行结果:
image.png

3、优缺点

优点：

  • 扩展性好。对于一个具体元素需要添加新的功能，可以直接新添加一个访问者来实现
  • 符合单一职责原则，每个访问者都是自己的单一功能

缺点：

  • 增加新元素困难：上面的例子当中只是针对外星人这一个元素，假设我们还需要添加一个【外星飞船】具体元素的时候，那么需要在抽象访问者接口IVisitor中去添加一个一个访问该具体元素的visit方法，那么此时所有的具体访问者，都需要去实现该元素的访问。

  • 由于我们的访问者的每个visit方法都是对应的具体的元素（比如上面的访问者对应的具体元素是外星人），我们的代码也就依赖了具体的实现，这是不符合依赖倒置原则的。

    4、应用场景

    当系统中存在类型数量稳定（固定）的一类数据结构时，可以使用访问者模式方便地实现对该类型所有数据结构的不同操作，而又不会对数据产生任何副作用（脏数据）。

  • 对象结构相对稳定，但其操作算法经常变化的程序。

  • 对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。
  • 对象结构包含很多类型的对象，希望对这些对象实施一些依赖于其具体类型的操作。