行为模式之十一---Visitor

1、结构图

2、代码

/*******************************************************************
* 意图：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变
*      各元素的类的前提下定义作用于这些元素的新操作。
* 适用性：
* 1、一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象
*    实施一些依赖于其具体类的操作。
* 2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你
*    想避免让这些操作“污染”这些对象的类。Visitor使得你可以将相关的
*    操作集中起来定义在一个类中。当该对象结构被很多应用共享时，用
*    Visitor模式让每个应用仅包含需要用到的操作。
* 3、定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改
*    变对象结构类需要重定义对所有访问者的接口，这可能需要很大的代价。
*    如果对象结构类经常改变，那么可能还是在这些类中定义这些操作较好。
* 协作：
* 1、一个是使用Visitor模式的客户必须创建一个ConcreteVisitor对象，然后
*   遍历该对象结构，并用该访问者访问每一个元素。
* 2、当一个元素被访问时，它调用对应于它的Visitor操作。如果必要，该元素
*    将自身作为一个参数以便该访问者访问它的状态。
* 作者：董怀信
* 日期：2009-06-10
* ****************************************************************/
using System;
using System.Collections.Generic;

namespace DesignPattern.BehavioralPattern
{
/// <summary>
/// 为该对象结构中ConcreteElement的每一个对象声明一个Visitor操作。该操作
/// 的名字和特征标识了发送Visitor请求给该访问者的那个类。这使得访问者可
/// 以确定正被访问元素的具体的类。这样访问者就可以通过该元素的特征接口直接
/// 访问它。
/// </summary>
public abstract class Visitor
{
public abstract void VisitConcreteElementA(ConcreteElementA elementA);
public abstract void VisitConcreteElementB(ConcreteElementB elementB);
}

/// <summary>
/// 定义一个Accept操作，它以一个访问者为参数。
/// </summary>
public abstract class Element
{
public abstract void Accept(Visitor visitor);
}

/// <summary>
/// 实现Accept操作，该操作以一个访问者为参数。
/// </summary>
public class ConcreteElementA : Element
{

public override void Accept(Visitor visitor)
{
visitor.VisitConcreteElementA(this);
}

public void OperationA()
{
Console.WriteLine("ConcreteElementA.OperationA();");
}
}

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

public void OperationB()
{
Console.WriteLine("ConcreteElementB.OperationB();");
}
}

/// <summary>
/// 实现每个由Visitor声明的操作。每个操作实现本算法的一部分，而该算法片段乃是
/// 对应于结构中类的对象。ConcreteVisitor对象为该算法提供了上下文并存储它的局部
/// 状态。这一状态常常在遍历该结构的过程中累积结果。
/// </summary>
public class ConcreteVisitor1 : Visitor
{
public override void VisitConcreteElementA(ConcreteElementA elementA)
{
Console.WriteLine("ConcreteVisitor1.VisitConcreteElementA();");
}

public override void VisitConcreteElementB(ConcreteElementB elementB)
{
Console.WriteLine("ConcreteVisitor1.VisitConcreteElementB();");
}
}

public class ConcreteVisitor2 : Visitor
{
public override void VisitConcreteElementA(ConcreteElementA elementA)
{
Console.WriteLine("ConcreteVisitor2.VisitConcreteElementA();");
}

public override void VisitConcreteElementB(ConcreteElementB elementB)
{
Console.WriteLine("ConcreteVisitor2.VisitConcreteElementB();");
}
}

/// <summary>
/// 能枚举它的元素。
/// 可以提供一个高层的接口以允许该访问者访问它的元素。
/// 可以是一个组合或是一个集合，如一个列表或一个无序集合。
/// </summary>
public class ObjectStructure
{
List<Element> m_elementList;
public ObjectStructure()
{
m_elementList = new List<Element>();
m_elementList.Add(new ConcreteElementA());
m_elementList.Add(new ConcreteElementB());
}

public void Accept(Visitor visitor)
{
foreach (Element item in m_elementList)
{
item.Accept(visitor);
ConcreteElementA elementA = item as ConcreteElementA;
if (elementA != null)
{
elementA.OperationA();
}
else
{
ConcreteElementB elementB = item as ConcreteElementB;
elementB.OperationB();
}
}
}
}

public class Client
{
public void Test()
{
ObjectStructure structrue = new ObjectStructure();
Visitor visitor = new ConcreteVisitor1();
structrue.Accept(visitor);
visitor = new ConcreteVisitor2();
structrue.Accept(visitor);
}
}
}