访问者模式(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、定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改变对象结构类需要重定义对所有访问者的接口，这可能需要很大的代价。如果对象结构类经常改变，那么可能还是在这些类中定义这些操作较好。

适用性：

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

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