学习设计模式第二十六 - 访问者模式

示例代码来自DoFactory。

概述

当你想要为一个对象的组合增加新的能力，且封装并不重要时，就使用访问者模式。

 

意图

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

 

UML

 

图1 Visitor模式UML图

 

 

参与者

这个模式涉及的类或对象：

  • Visitor

    • 定义一个针对对象结构中每一个ConcreteElement类的Visit操作。操作的名字和签名指明将Visit请求发送给visitor的类。其让visitor决定被访问的具体元素类型。这样visitor可以通过其特定的接口直接访问元素。

  • ConcreteVisitor

    • 实现Visitor声明的每一个操作。每一个操作实现了用于结构中相应的类或对象的算法片段。ConcreteVisitor提供了算法上下文并存储其本地状态。在遍历结构的过程中，状态常将结果进行累加。

  • Element

    • 定义一个接收visitor作为参数的Accept操作。

  • ConcreteElement

    • 实现一个接收visitor作为参数的Accept操作。

  • ObjectStructure

    • 可以遍历其元素

    • 可能提供一个高层接口来允许visitor访问其元素

    • 可能同时实现一个组合模式（作为Composite）或作为一个如列表或集一样的集合

 

适用性

在某些情况下，你会需要更改一个类型集合的功能但是你不能控制层次中的类型。这是Visitor模式出场的地方：Visitor模式的意图是为一个类型的集合定义一个新的操作（如，被访问的类型）而无须更改层次本身。新的逻辑位于一个单独的类，如Visitor中。Visitor模式的棘手的方面在于集合中类的原始开发者必须预计到在将来可能发生的功能调整，而在其中包含可以接收Visitor类对象并允许这个对象定义新操作的方法。

Visitor是一个有争议的模式，有经验的.NET开发者常避免使用它。争议在于其添加了复杂性并创造出与面向对象设计中普遍接受的最佳实践相反的脆弱的代码。当决定使用这种模式时，通常最好的做法是仔细衡量，对于替代方案，如继承或委托，后者更可能给你的问题提供一个更健壮的解决方案。

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

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

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

 

DoFactory GoF代码

这个Visitor模式的示例中，一个对象遍历一个对象结构并且在结构中每一个节点上执行相同的操作。不同的visitor对象定义不同的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
// Visitor pattern 
// Structural example 
using System;
using System.Collections.Generic;
  
namespace DoFactory.GangOfFour.Visitor.Structural
{
    // MainApp test application
    class MainApp
    {
        static void Main()
        {
            // Setup structure
            ObjectStructure o = new ObjectStructure();
            o.Attach(new ConcreteElementA());
            o.Attach(new ConcreteElementB());
  
            // Create visitor objects
            ConcreteVisitor1 v1 = new ConcreteVisitor1();
            ConcreteVisitor2 v2 = new ConcreteVisitor2();
  
            // Structure accepting visitors
            o.Accept(v1);
            o.Accept(v2);
  
            // Wait for user
            Console.ReadKey();
        }
    }
  
    // "Visitor"
    abstract class Visitor
    {
        public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);
        public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
    }
  
    // "ConcreteVisitor"
    class ConcreteVisitor1 : Visitor
    {
        public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
        {
            Console.WriteLine("{0} visited by {1}",concreteElementA.GetType().Name, this.GetType().Name);
        }
  
        public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
        {
            Console.WriteLine("{0} visited by {1}",concreteElementB.GetType().Name, this.GetType().Name);
        }
    }
  
    // "ConcreteVisitor"
    class ConcreteVisitor2 : Visitor
    {
        public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
        {
            Console.WriteLine("{0} visited by {1}", concreteElementA.GetType().Name, this.GetType().Name);
        }
  
        public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
        {
            Console.WriteLine("{0} visited by {1}", concreteElementB.GetType().Name, this.GetType().Name);
        }
    }
  
    // "Element"
    abstract class Element
    {
        public abstract void Accept(Visitor visitor);
    }
  
    // "ConcreteElement"
    class ConcreteElementA : Element
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitConcreteElementA(this);
        }
  
        public void OperationA()
        {
        }
    }
  
    // "ConcreteElement"
    class ConcreteElementB : Element
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitConcreteElementB(this);
        }
  
        public void OperationB()
        {
        }
    }
  
    // "ObjectStructure"
    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 (Element element in _elements)
            {
                element.Accept(visitor);
            }
        }
    }
}

这个现实世界的访问者模式的例子中，两个visitor对象遍历一个Employee列表并在每一个Employee上执行相同的操作。两个visitor对象定义不同的操作 – 一个调整休假日期另一个调整收入。

例子中涉及到的类与访问者模式中标准的类对应关系如下：

  • Visitor – Visitor

  • ConcreteVisitor – IncomeVisitor, VacationVisitor

  • Element – Element

  • ConcreteElement – Employee

  • ObjectStructure – Employees

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
// Visitor pattern 
// Real World example 
using System;
using System.Collections.Generic;
  
namespace DoFactory.GangOfFour.Visitor.RealWorld
{
    // MainApp startup application
    class MainApp
    {
        static void Main()
        {
            // Setup employee collection
            Employees e = new Employees();
            e.Attach(new Clerk());
            e.Attach(new Director());
            e.Attach(new President());
  
            // Employees are 'visited'
            e.Accept(new IncomeVisitor());
            e.Accept(new VacationVisitor());
  
            // Wait for user
            Console.ReadKey();
        }
    }
  
    // "Visitor"
    interface IVisitor
    {
        void Visit(Element element);
    }
  
    // "ConcreteVisitor"
    class IncomeVisitor : IVisitor
    {
        public void Visit(Element element)
        {
            Employee employee = element as Employee;
  
            // Provide 10% pay raise
            employee.Income *= 1.10;
            Console.WriteLine("{0} {1}'s new income: {2:C}",employee.GetType().Name, employee.Name, employee.Income);
        }
    }
  
    // "ConcreteVisitor"
    class VacationVisitor : IVisitor
    {
        public void Visit(Element element)
        {
            Employee employee = element as Employee;
  
            // Provide 3 extra vacation days
            Console.WriteLine("{0} {1}'s new vacation days: {2}", employee.GetType().Name, employee.Name, employee.VacationDays);
        }
    }
  
    // "Element"
    abstract class Element
    {
        public abstract void Accept(IVisitor visitor);
    }
  
    // "ConcreteElement"
    class Employee : Element
    {
        private string _name;
        private double _income;
        private int _vacationDays;
  
        // Constructor
        public Employee(string name, double income, int vacationDays)
        {
            this._name = name;
            this._income = income;
            this._vacationDays = vacationDays;
        }
  
        // Gets or sets the name
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
  
        // Gets or sets income
        public double Income
        {
            get { return _income; }
            set { _income = value; }
        }
  
        // Gets or sets number of vacation days
        public int VacationDays
        {
            get { return _vacationDays; }
            set { _vacationDays = value; }
        }
  
        public override void Accept(IVisitor visitor)
        {
            visitor.Visit(this);
        }
    }
  
    // "ObjectStructure"
    class Employees
    {
        private List<Employee> _employees = new List<Employee>();
  
        public void Attach(Employee employee)
        {
            _employees.Add(employee);
        }
  
        public void Detach(Employee employee)
        {
            _employees.Remove(employee);
        }
  
        public void Accept(IVisitor visitor)
        {
            foreach (Employee e in _employees)
            {
                e.Accept(visitor);
            }
            Console.WriteLine();
        }
    }
  
    // Three employee types
    class Clerk : Employee
    {
        // Constructor
        public Clerk()
            : base("Hank", 25000.0, 14)
        {
        }
    }
  
    class Director : Employee
    {
        // Constructor
        public Director()
            : base("Elly", 35000.0, 16)
        {
        }
    }
  
    class President : Employee
    {
        // Constructor
        public President()
            : base("Dick", 45000.0, 21)
        {
        }
    }
}

这个例子实现了与上述例子相同的功能，更多的使用了更现代的，内置的.NET特性。在这个例子中Visitor模式使用了反射。这种方式让我们可以有选择的选择想要visit哪一个Employee。ReflectiveVisit()查找一个参数兼容的Visit()方法。注意反射的使用使Visitor更灵活但也更慢且更复杂。这个例子将employee的集合存储在一个泛型List<Employee>列表中。这个例子中用到的.NET 3.0的特性包括Employee类中自动属性及Employees类中的Foreach扩展方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
// Visitor pattern 
// .NET Optimized example 
using System;
using System.Collections.Generic;
using System.Reflection;
  
namespace DoFactory.GangOfFour.Visitor.NETOptimized
{
    class MainApp
    {
        static void Main()
        {
            // Setup employee collection
            var e = new Employees();
            e.Attach(new Clerk());
            e.Attach(new Director());
            e.Attach(new President());
  
            // Employees are 'visited'
            e.Accept(new IncomeVisitor());
            e.Accept(new VacationVisitor());
  
            // Wait for user
            Console.ReadKey();
        }
    }
  
    // "Visitor"
    public abstract class Visitor
    {
        // Use reflection to see if the Visitor has a method 
        // named Visit with the appropriate parameter type 
        // (i.e. a specific Employee). If so, invoke it.
        public void ReflectiveVisit(IElement element)
        {
            var types = new Type[] { element.GetType() };
            var mi = this.GetType().GetMethod("Visit", types);
  
            if (mi != null)
            {
                mi.Invoke(this, new object[] { element });
            }
        }
    }
  
    // "ConcreteVisitor"
    class IncomeVisitor : Visitor
    {
        // Visit clerk
        public void Visit(Clerk clerk)
        {
            DoVisit(clerk);
        }
  
        // Visit director
        public void Visit(Director director)
        {
            DoVisit(director);
        }
  
        private void DoVisit(IElement element)
        {
            var employee = element as Employee;
  
            // Provide 10% pay raise
            employee.Income *= 1.10;
            Console.WriteLine("{0} {1}'s new income: {2:C}",
                employee.GetType().Name, employee.Name,
                employee.Income);
        }
    }
  
    // "ConcreteVisitor"
    class VacationVisitor : Visitor
    {
        // Visit director
        public void Visit(Director director)
        {
            DoVisit(director);
        }
  
        private void DoVisit(IElement element)
        {
            var employee = element as Employee;
  
            // Provide 3 extra vacation days
            employee.VacationDays += 3;
            Console.WriteLine("{0} {1}'s new vacation days: {2}",
                employee.GetType().Name, employee.Name,
                employee.VacationDays);
        }
    }
  
    // "Element"
    public interface IElement
    {
        void Accept(Visitor visitor);
    }
  
    // "ConcreteElement"
    class Employee : IElement
    {
        // Constructor
        public Employee(string name, double income,
            int vacationDays)
        {
            this.Name = name;
            this.Income = income;
            this.VacationDays = vacationDays;
        }
  
        // Gets or sets name
        public string Name { get; set; }
  
        // Gets or set income
        public double Income { get; set; }
  
        // Gets or sets vacation days
        public int VacationDays { get; set; }
  
        public virtual void Accept(Visitor visitor)
        {
            visitor.ReflectiveVisit(this);
        }
    }
  
    // "ObjectStructure"
    class Employees : List<Employee>
    {
        public void Attach(Employee employee)
        {
            Add(employee);
        }
  
        public void Detach(Employee employee)
        {
            Remove(employee);
        }
  
        public void Accept(Visitor visitor)
        {
            // Iterate over all employees and accept visitor
            this.ForEach(employee => employee.Accept(visitor));
             
            Console.WriteLine();
        }
    }
  
    // Three employee types
    class Clerk : Employee
    {
        // Constructor
        public Clerk()
            : base("Hank", 25000.0, 14)
        {
        }
    }
  
    class Director : Employee
    {
        // Constructor
        public Director()
            : base("Elly", 35000.0, 16)
        {
        }
    }
  
    class President : Employee
    {
        // Constructor
        public President()
            : base("Dick", 45000.0, 21)
        {
        }
    }
}

 

访问者模式解说

访问者必须参观组合内的每个元素，这样的功能是在Traverser对象中，访问者通过Traverser的引导，收集组合中所有对象的状态。一旦收集了状态，客户就可以让访问者对状态进行各种操作。当需要新的功能时，只要加强访问者即可。

访问者模式适用于数据结构相对稳定的系统。它把数据结构和作用于结构上的操作之间的耦合进行分解，使操作集合可以相对自由地演化。

访问者模式的目的是要把处理从数据结构分离出来。如果系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式就比较适合，因为访问者模式使得算法操作的增加变得容易。

 

.NET中的代理模式

在.NET Framework类库中没有用到Visitor模式。

 

效果及实现要点

优点：

允许你对组合结构加入新的操作，而无需改变结构本身。

想要加入新的操作，相对容易。

访问者所进行的操作，其代码是集中在一起的。

增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。

 

缺点：

当采用访问者模式的时候，就会打破组合类的封装。

因为游走到功能牵涉其中，所以对组合结构的改变就更加困难（增加新的数据结构更困难）。

 

总结

访问者模式把数据处理从数据结构分离出来，可以在不改变数据结构的情况下，替换现有处理方式或增加新的处理功能。

posted @   hystar  阅读(453)  评论(0)  编辑  收藏  举报
编辑推荐：
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· C#/.NET/.NET Core技术前沿周刊 | 第 29 期（2025年3.1-3.9）
· 从HTTP原因短语缺失研究HTTP/2和HTTP/3的设计差异
历史上的今天：
2013-03-15 WPF，Silverlight与XAML读书笔记第三十八 - 可视化效果之2D图形
点击右上角即可分享
微信分享提示