设计模式笔记 23. Visitor 访问者模式(行为型模式)

 

23. Visitor 访问模式

2008-09-26

动机 (Motivation)

在软件构建过程中，由于需求的改变，某些层次结构中常常需要增加新行为（方法），如果直接在基类中做这样的更改，将会给子类带来很繁重的变更负担，甚至破坏原有设计。

如何在不更改类层次结构的前提下，在运行时根据需要透明地为类层次结构上的各个分类动态添加新的操作，从而避免上述问题。

意图 (Intent)

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

场景：

图形系统，假设其图像种类稳定，而其可提供的操作变化。

 

基本代码：

     // 为该对象结构中ConcreteElement的每一个类声明一个Visitor操作
     abstract   class  Visitor
     {
        public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);

        public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
    }

 

// 具体访问者，实现每个由Visitor声明的操作，每个操作实现算法的一部分，而该算法片断乃是对于结构中对象的类
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);
    }
}

 

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

 

     // 具体元素，实现Accept操作
     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);
            }
        }
    }

客户端代码：

     class  Program
     {
        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模式的几个要点：

 1、本模式通过所谓双重分发（double dispatch）来实现在不更改Element类层次结构的前提下，在运行时透明地为类层次结构上的各个类动态添加新的操作。
        2、所谓双重分发即Visitor模式中包含两个多态分发（注意其中的的多态机制）：第一个为Accept方法的多态辨析，第二个为Visit方法的多态辨析。
        3、Visitor模式最大的缺点在于扩展类层次结构（增加新的Element子类），会导致Visitor类的改变。因此本模式适用于“Element类层次结构稳定，而其中的操作却面临频繁变动”。