访问者模式(Visitor)

访问者模式(Visitor)：

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

结构图：





示例代码：

public class VisitorMode
{
public void Main()
{
ObjectStructure o = new ObjectStructure();
o.Attach(new Man());
o.Attach(new Woman());

Success s1 = new Success();
o.Display(s1);

Failing f1 = new Failing();
o.Display(f1);
}
}

/// <summary>
/// 定义Visit操作
/// </summary>
public abstract class Visitor
{
//操作1
public abstract void VisitConcreteElementA(ConcreteElementA concreteElementOne);

//操作2
public abstract void VisitConcreteElementB(ConcreteElementB concreteElementTwo);
}

//操作1
public class ConcreteVisitorOne : Visitor
{
public override void VisitConcreteElementA(ConcreteElementA concreteElementOne)
{
Console.WriteLine("{0}被{1}存取", concreteElementOne.GetType().Name, this.GetType().Name);
}

public override void VisitConcreteElementB(ConcreteElementB concreteElementTwo)
{
Console.WriteLine("{0}被{1}存取", concreteElementTwo.GetType().Name, this.GetType().Name);
}
}
//操作2
public class ConcreteVisitorTwo : Visitor
{
public override void VisitConcreteElementA(ConcreteElementA concreteElementOne)
{
Console.WriteLine("{0}被{1}存取", concreteElementOne.GetType().Name, this.GetType().Name);
}

public override void VisitConcreteElementB(ConcreteElementB concreteElementTwo)
{
Console.WriteLine("{0}被{1}存取", concreteElementTwo.GetType().Name, this.GetType().Name);
}
}

//访问者
public abstract class ElementVisitor
{
public abstract void Accept(Visitor visitor);
}

//访问者A
public class ConcreteElementA : ElementVisitor
{
public override void Accept(Visitor visitor)
{
visitor.VisitConcreteElementA(this);
}

public void OperactionA() { }
}

//访问者B
public class ConcreteElementB : ElementVisitor
{
public override void Accept(Visitor visitor)
{
visitor.VisitConcreteElementB(this);
}

public void OperactionB() { }
}

/// <summary>
/// 结构对象
/// </summary>
class VisitorObjectStructure
{
private IList<ElementVisitor> elements = new List<ElementVisitor>();

public void Attach(ElementVisitor element)
{
elements.Add(element);
}

public void Detch(ElementVisitor element)
{
elements.Remove(element);
}

public void Accept(Visitor element)
{
foreach (ElementVisitor item in elements)
{
item.Accept(element);
}
}
}

优点：

A、访问者模式使得易于增加新的操作。 访问者使得增加依赖于复杂对象结构的构件的操作变得容易了。仅需增加一个新的访问者即可在一个对象结构上定义一个新的操作。相反，如果每个功能都分散在多个类之上的话，定义新的操作时必须修改每一类。
B、访问者集中相关的操作而分离无关的操作。相关的行为不是分布在定义该对象结构的各个类上，而是集中在一个访问者中。无关行为却被分别放在它们各自的访问者子类中。这就既简化了这些元素的类，也简化了在这些访问者中定义的算法。所有与它的算法相关的数据结构都可以被隐藏在访问者中。
C、增加新的C o n c r e t e E l e m e n t类很困难。Vi s i t o r模式使得难以增加新的E l e m e n t的子类。每添加一个新的 C o n c r e t e E l e m e n t都要在 Vi s t o r中添加一个新的抽象操作，并在每一个C o n c r e t Vi s i t o r类中实现相应的操作。
D、通过类层次进行访问。一个迭代器（参见I t e r a t o r（5 . 4） ）可以通过调用节点对象的特定操作来遍历整个对象结构，同时访问这些对象。但是迭代器不能对具有不同元素类型的对象结构进行操作。
E、累积状态。当访问者访问对象结构中的每一个元素时，它可能会累积状态。
F、破坏封装。访问者方法假定C o n c r e t e E l e m e n t接口的功能足够强，足以让访问者进行它们的工作。结果是，该模式常常迫使你提供访问元素内部状态的公共操作，这可能会破坏它的封装性。

缺点：

A、一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。
B、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。 Vi s i t o r使得你可以将相关的操作集中起来定义在一个类中。当该对象结构被很多应用共享时，用Vi s i t o r模式让每个应用仅包含需要用到的操作。
C、定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改变对象结构类需要重定义对所有访问者的接口，这可能需要很大的代价。如果对象结构类经常改变，那么可能还是在这些类中定义这些操作较好。

适用性：

访问者模式适用于资料结构相对稳定的系统，它把资料结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。

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