访问者模式

UML类图：

实例实现代码：

    abstract class Visitor
    {
        public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);

        public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
    }

    class ConcreteVisitor1 : Visitor
    {
        public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
        {
            Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
        }

        public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
        {
            Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
        }
    }

    class ConcreteVisitor2 : Visitor
    {
        public override void VisitConcreteElementA(ConcreteElementA concreteElementA)
        {
            Console.WriteLine("{0}被{1}访问", concreteElementA.GetType().Name, this.GetType().Name);
        }

        public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
        {
            Console.WriteLine("{0}被{1}访问", concreteElementB.GetType().Name, this.GetType().Name);
        }
    }

    abstract class Element
    {
        public abstract void Accept(Visitor visitor);
    }

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

        public void OperationA()
        { }
    }

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

        public void OperationB()
        { }
    }

    class ObjectStructure
    {
        private IList<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 e in elements)
            {
                e.Accept(visitor);
            }
        }
    }

客户端实现：

        static void Main(string[] args)
        {
            ObjectStructure o = new ObjectStructure();
            o.Attach(new ConcreteElementA());
            o.Attach(new ConcreteElementB());

            ConcreteVisitor1 v1 = new ConcreteVisitor1();
            ConcreteVisitor2 v2 = new ConcreteVisitor2();

            o.Accept(v1);
            o.Accept(v2);

            Console.Read();
        }

说明：

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

角色：

Visitor ：
抽象访问者角色，为该对象结构中具体元素角色声明一个访问操作接口。该操作接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色，这样访问者就可以通过该元素角色的特定接口直接访问它。
ConcreteVisitor：
具体访问者角色，实现Visitor声明的接口。
Element ：
定义一个接受访问操作(accept())，它以一个访问者(Visitor)作为参数。
ConcreteElement ：
具体元素，实现了抽象元素(Element)所定义的接受操作接口。
ObjectStructure ：
结构对象角色，这是使用访问者模式必备的角色。它具备以下特性：能枚举它的元素；可以提供一个高层接口以允许访问者访问它的元素；如有需要，可以设计成一个复合对象或者一个聚集（如一个列表或无序集合）。

PS：通过一个自己构思的例子来讲解这个模式：我们假设理发店有很多理发师，他们分为高级，中级和初级，每个等级对不同的人（这里假设男人，女人和小孩）的收费有所差异。

接受者（Element）：人

           （ConcreteElement）：男人，女人，小孩。

访问者（Visitor）：理发师

           （ConcreteVisitor）：高级理发师，中级理发师，初级理发师。

结构对象角色  （ConcreteElement）：管理理发人员，很多小孩，男人和女人。

具体理发师实现visitChild：，visitMan：，visitWoman：三个访问方法来打印价格信息。

具体理发者实现accept：方法来理发，我们通过一个高级理发师给小孩理发来说明这个逻辑流程。

例如 [child accept:一个高级理发师对象]

这个方法的具体实现就是调用这个高级理发师的 visitChild：方法，即[一个高级理发师对象 visitChild:self]

参考资料

-《大话设计模式》