设计模式学习：Visitor模式

一、概述

    DP一书对Visitor模式的定义：表示一个作用于某对象结构中的各个元素的操作。它可以在不改变各个元素的类的前提下定义作用于这个元素的新的操作。

    在软件构建的过程中，由于需求的变化我们常常需要扩展已有的类层次结构（如：增加新的行为）。如果直接在基类中进行修改，将会给子类带来繁重的变更负担，甚至破坏原有的设计。而且有些情况下，我们扩展生成的行为与现有对象模型是不一致的或无法访问现有的程序代码。

如何在不改变一个层次结构中的类的情况下，在运行时根据需求透明地为一个层次结构定义一个新的操作呢？

二、分析问题

考虑下面的问题：不同类型的形状（Shape）有各自的特点，因此子类（Rectangle、Circle）中的实现方法也各不相同。这时如果子类扩展了父类，我们如何使用这些功能呢？

我们可能会有如下实现：

 1 abstract class Shape
 2    {
 3        public abstract void ShowArea();
 4    }
 5
 6    //Rectangle
 7    class Rectangle : Shape
 8    {
 9        private int width;
10        private int height;
11
12        public Rectangle(int width, int height)
13        {
14            this.width = width;
15            this.height = height;
16        }
17
18        public override void ShowArea()
19        {
20            Console.WriteLine("The Rectangle's Area is:" + width * height+"!");
21        }
22    }
23
24    //Circle
25    class Circle : Shape
26    {
27        const float pi = 3.14f;
28        private int radius;
29
30        public int Radius
31        {
32            get { return this.radius; }
33        }
34
35        public Circle(int radius)
36        {
37            this.radius = radius;
38        }
39
40        public override void ShowArea()
41        {
42            Console.WriteLine("The Circle's Area is:" + pi * radius * radius + "!");
43        }
44
45        //子类扩展的功能
46        public void Draw()
47        {
48            Console.WriteLine("Let's Draw a cirle,the circle's radius is:"+ this.Radius+"!");
49        }
50    }
51
52    //Test Application
53    class AppTest
54    {
55        public static void Main()
56        {
57            Rectangle rectangle = new Rectangle(5, 3);
58            Circle circle = new Circle(3);
59            Display(rectangle);
60            Display(circle);
61     
62            Console.ReadKey();
63        }
64        static void Display(Shape shape)
65        {
66            shape.ShowArea();
67
68            //不得不进行类型判断和强制类型转换
69            if (shape.GetType().Name == "Circle")
70            {
71                ((Circle)shape).Draw();
72            }
73        }
74    }

    运行结果：The Rectangle's Area is:15!
              The Circle's Area is 28.26!
              Let's Draw a circle,the circle's radius is 3!

一方面，我们希望接口统一的前提下使用子类的功能。另一方面，我们又不得不进行类型判断，并且常常需要强制类型转换。这实际上违背了面向接口的设计原则，因为我们必须针对某种实现执行特定的代码。此外，如果由于需求的变更Shape类需要增加新的方法，那么其子类将不得不随之更改。

三、Visitor模式的UML类图

       

 
         由图可见，Visitor模式适用于类结构稳定的系统 （类或子类一旦确定，就不会经常修改或增加新的类）。因为访问者（Visitor）依赖于类结构中的所有子类，一旦子类发生变化，访问者及相应的子类都要随之变化。

 

         但是仅仅这个理由是不够的，正如Ralph Johnson（DP的作者之一）所说：“大多时候你不需要Visitor，但是一旦你需要Visitor，那就是真的需要Visitor了”。一般来说，当你有很多运行在不同对象结构中的算法，并且没有其他的解决方案比Visitor更简单或简洁的时候，你就需要Visitor。

         通过使用双重分派（double-dispatch），Visitor可以很容易的与不同的类进行交互。这意味着类集合中的每一个类都接受一个Visitor作为参数（通过一个“接受”方法：Accept(Visitor visitor)）的方法，然后回调这个Visitor，把自己传入相应的访问方法中。

         因为传入Visitor的Visitor(….)方法的参数是一个特殊类型的实例，所以Visitor可以调用这个实例上的特定方法，而不需要做类型转换。这就使得Visitor可以访问统一继承结构或不同继承结构中的类。

通过访问者为对象增加操作与在对象内部直接增加操作是不同的，在某些情况下，为了使访问者访问对象的内部变量，对象将不得不暴露一些自己的操作和状态。另外，由于访问者对象自己会积累访问操作所需的状态，从而使这些状态不再存储在相应的元素中，这都破坏了对象的封装性。

四、具体的例子——汽车维修工程师检查汽车

    （1）类图

 

    （2）实现代码

  1 //Abstract Visitor
  2    interface IVisitor
  3    {
  4        void Visit(Wheel wheel);
  5        void Visit(Engine engine);
  6        void Visit(Body body);
  7        void Visit(Car car);
  8    }
  9
 10    //Element:Wheel
 11    class Wheel
 12    {
 13        private string name;
 14
 15        public string Name
 16        {
 17            get { return this.name; } 
 18        }
 19
 20        public Wheel(string name)
 21        {
 22            this.name = name;
 23        }
 24
 25        public void Accept(Engineer engineer)
 26        {
 27            engineer.Visit(this);
 28        }
 29    }
 30    //Element:Body
 31    class Body
 32    {
 33        public void Accept(Engineer engineer)
 34        {
 35            engineer.Visit(this);
 36        }
 37    }
 38    //Element:Engine
 39    class Engine
 40    {
 41        public void Accept(Engineer engineer)
 42        {
 43            engineer.Visit(this);
 44        }
 45    }
 46    //Object Structure
 47    class Car
 48    {
 49        private Wheel[] wheels = { new Wheel("Left_Front Wheel"), new Wheel("Right_Front Wheel"), new Wheel("Left_Bank Wheel"), new Wheel("Right_Bank Wheel") };
 50        private Body body = new Body();
 51        private Engine engine = new Engine();
 52
 53        public void Accept(Engineer engineer)
 54        {
 55            engineer.Visit(this);
 56            for (int i = 0; i < wheels.Length; i++)
 57            {
 58                ((Wheel)wheels[i]).Accept(engineer);
 59            }
 60            engine.Accept(engineer);
 61            body.Accept(engineer);
 62        }
 63    }
 64    //Concrete Visitor:Engineer
 65    class Engineer : IVisitor
 66    {
 67        private string name;
 68
 69        public Engineer(string name)
 70        {
 71            this.name = name;
 72        }
 73
 74        public void Visit(Wheel wheel)
 75        {
 76            Console.WriteLine("Check" + wheel.Name + "Complete!");
 77        }
 78        public void Visit(Engine engine)
 79        {
 80            Console.WriteLine("Check Engine Complete!");
 81        }
 82        public void Visit(Body body)
 83        {
 84            Console.WriteLine("Check Body Complete!");
 85        }
 86        public void Visit(Car car)
 87        {
 88            Console.WriteLine(this.name +" is Checking Car.");
 89            Console.WriteLine("--------------------------------");
 90        }
 91
 92       
 93    }
 94
 95    //Test App
 96    class AppTest
 97    {
 98
 99        public static void Main()
100        {
101            Car car = new Car();
102            Engineer engineer = new Engineer("Mike");
103
104            car.Accept(engineer);
105            Console.ReadKey();
106        }
107    }

         运行结果：Mike is Checking Car....
                            ---------------------------------------
                            Check Left_Front Wheel Complete!
                            Check Right_Front Wheel Complete!
                            Check Left_Bank Wheel Complete!
                            Check Right_Bank Wheel Complete!

[参考文献]Refactoring to Patterns