设计模式（二十四）—访问者模式（行为型）

• 一、简介（Brief Introduction）

         封装某些作用于某种数据结构中各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。

          在软件开发过程中，对于系统中的某些对象，它们存储在同一个集合collection中，且具有不同的类型，而且对于该集合中的对象，可以接受一类称为访问者的对象来访问，而且不同的访问者其访问方式有所不同。

  例子1：顾客在超市中将选择的商品，如苹果、图书等放在购物车中，然后到收银员处付款。在购物过程中，顾客需要对这些商品进行访问，以便确认这些商品的质量，之后收银员计算价格时也需要访问购物车内顾客所选择的商品。此时，购物车作为一个ObjectStructure（对象结构）用于存储各种类型的商品，而顾客和收银员作为访问这些商品的访问者，他们需要对商品进行检查和计价。不同类型的商品其访问形式也可能不同，如苹果需要过秤之后再计价，而图书不需要。

  二、模式分析（Analysis）

  
  

  抽象访问者（Vistor）: — 为该对象结构中ConcreteElement的每一个类声明一个Visit操作。该操作的名字和特

  征标识了发送Visit请求给该访问者的那个类。这使得访问者可以确定正被访问元素

  的具体的类。这样访问者就可以通过该元素的特定接口直接访问它。

  具体访问者（ConcreteVisitor）: — 实现每个由Visitor声明的操作。每个操作实现本算法的一部分，而该算法片断乃是

  对应于结构中对象的类。ConcreteVisitor为该算法提供了上下文并存储它的局部状态。

  这一状态常常在遍历该结构的过程中累积结果。

   抽象元素（Element）：定义一个Accept操作，它以一个访问者为参数。

  具体元素（ConcreteElement）:   实现Accept操作，该操作以一个访问者为参数。

  对象结构（ObjectStructure）: 能枚举它的元素。可以提供一个高层的接口以允许该访问者访问它的元素。可以是一个复合或是一个集合，如一个列表或一个无序集合。

  三、案例分析（Example）

  namespace 访问者模式
  {

  1、客户端
  

    class Program
      {
          static void Main(string[] args)
          {
              ObjectStructure o=new ObjectStructure() ;
              o.Attach(new ConcreteElementA());
              o.Attach(new ConcreteElementB());
  
              ConcreteVisitor1 v1 = new ConcreteVisitor1();
              ConcreteVisitor2 v2=new ConcreteVisitor2 ();
  
              o.Accept (v1);
              o.Accept (v2);
  
              Console .Read ();
  
          }
      }

  2、Visitor
  

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

  3、具体的访问者
  

      class ConcreteVisitor1 : Visitor
      {
          public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
          {
              Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
          }
          public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
          {
              Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
          }
      }
      class ConcreteVisitor2 : Visitor
      {
          public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
          {
              Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
          }
          public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
          {
              Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
          }
      }

  4、Element类
  

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

  5、具体的类
  

      class ConcreteElementA : Element
      {
          public override void Accept(Visitor visitor)
          {
              visitor.VisitConcreteElementA(this);
          }
          public void OperationA()
          { }
      }
  
      class ConcreteElementB : Element
      {
          public override void Accept(Visitor visitor)
          {
              visitor.VisitConcreteElementB(this);
          }
          public void OperationB()
          { }
      }

  6、结构类
  

      class ObjectStructure
      {
          private IList<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 (Element e in  elements)
              {
                  e.Accept(visitor);
              }
          }
      }
  }

  四、解决的问题（What To Solve）

  • 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。

  • 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。 Visitor使得你可以将相关的操作集中起来定义在一个类中。当该对象结构被很多应用共享时，用Visitor模式让每个应用仅包含需要用到的操作。

  • 定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改变对象结构类需要重定义对所有访问者的接口，这可能需要很大的代价。如果对象结构类经常改变，那么可能还是在这些类中定义这些操作较好。

  五、优缺点（Advantage and Disadvantage）

  优点：

  • 符合单一职责原则：凡是适用访问者模式的场景中，元素类中需要封装在访问者中的操作必定是与元素类本身关系不 大且是易变的操作，使用访问者模式一方面符合单一职责原则，另一方面，因为被封装的操作通常来说都是易变的，所以当发生变化时，就可以在不改变元素类本身 的前提下，实现对变化部分的扩展。
  • 将有关元素对象的访问行为集中到一个访问者对象中，而不是分散到一个个的元素类中。
  • 访问者模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。迭代子只能访问属于同一个类型等级结构的成员对象，而不能访问属于不同等级结构的对象。访问者模式可以做到这一点。
  • 让用户能够在不修改现有类层次结构的情况下，定义该类层次结构的操作。

  缺点:

  • 增加新的元素类很困难。在访问者模式中，每增加一个新的元素类都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作，违背了“开闭原则”的要求。
  • 破坏封装。访问者模式要求访问者对象访问并调用每一个元素对象的操作，这意味着元素对象有时候必须暴露一些自己的内部操作和内部状态，否则无法供访问者访问。

  六、扩展（Extend）

  1）访问者模式中对象结构存储了不同类型的元素对象，以供不同访问者访问。

  2）访问者模式包括两个层次结构，一个是访问者层次结构，提供了抽象访问者和具体访问者，一个是元素层次结构，提供了抽象元素和具体元素。

  相同的访问者可以以不同的方式访问不同的元素，相同的元素可以接受不同访问者以不同访问方式访问。在访问者模式中，增加新的访问者无须修改原有系统，系统具有较好的可扩展性