设计模式笔记（二十四） —— 访问者模式

访问者模式(Visitor)：表示一个作用于某对象结构中的各种元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
      访问者模式适用于数据结构相对稳定的系统。它把数据结构和作用于结构上的操作之间的耦合解脱开，便得操作集合可以相对自由地演化。访问者模式的目的是要把处理从数据结构分离出来。有比较稳定的数据结构，又易于变化的算法的话，使用访问者模式就是比较合适的，因为访问者模式使得算法操作的增加变得容易。
      访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问对象中。缺点就是使增加新的数据结构变得困难了。 

1. using System;
2. using System.Collections.Generic;
4. /**概述：
5.  * 访问者模式(Visitor):表示一个作用于某对象结构中的各种元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
6.  * 访问者模式适用于数据结构相对稳定的系统。它把数据结构和作用于结构上的操作之间的耦合解脱开，便得操作集合可以相对自由地演化。访问者模式的目的是要把处理从数据结构分离出来。有比较稳定的数据结构，又易于变化的算法的话，使用访问者模式就是比较合适的，因为访问者模式使得算法操作的增加变得容易。
7.  * 访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问对象中。缺点就是使增加新的数据结构变得困难了。
8.  */
9. namespace StuDesignMode.visitor
10. {
11.    abstract class AbsVisitor
12.     {
13.        public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);
15.        public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
16.     }
18.    class ConcreteVisitor1 : AbsVisitor
19.    {
20.        public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
21.        {
22.            Console.WriteLine("{0}被{1}访问",concreteElementA.GetType().Name,this.GetType().Name);
23.        }
25.        public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
26.        {
27.            Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
28.        }
29.    }
31.    class ConcreteVisitor2 : AbsVisitor
32.    {
33.        public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
34.        {
35.            Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
36.        }
38.        public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
39.        {
40.            Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
41.        }
42.    }
44.    abstract class Element
45.    {
46.        public abstract void Accept(AbsVisitor visitor);
47.    }
49.    class ConcreteElementA:Element
50.    {
51.        public override void Accept(AbsVisitor visitor)
52.        {
53.            visitor.VisitConcreteElementA(this);
54.        }
55.    }
57.    class ConcreteElementB:Element
58.    {
59.        public override void Accept(AbsVisitor visitor)
60.        {
61.            visitor.VisitConcreteElementB(this);
62.        }
63.    }
65.    class ObjectStructure
66.    {
67.        private List<Element> list = new List<Element>();
69.        public void Attach(Element element)
70.        {
71.            list.Add(element);
72.        }
74.        public void Detach(Element element)
75.        {
76.            list.Remove(element);
77.        }
79.        public void Accept(AbsVisitor visitor)
80.        {
81.            foreach (Element e in list)
82.            {
83.                e.Accept(visitor);
84.            }
85.        }
86.    }
88.    class ClientTest
89.    {
90.        static void Main(string[] args)
91.        {
92.            ObjectStructure o = new ObjectStructure();
94.            o.Attach(new ConcreteElementA());
95.            o.Attach(new ConcreteElementB());
97.            ConcreteVisitor1 v1 = new ConcreteVisitor1();
98.            ConcreteVisitor2 v2 = new ConcreteVisitor2();
100.            o.Accept(v1);
101.            o.Accept(v2);
103.            Console.WriteLine();
104.        }
105.    }
106. }