设计模式之访问者模式(Visitor1)

访问者模式（Visitor）：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
访问者模式的目的是要把处理从数据结构分离出来，当系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式就是比较合适的，访问者模式使得算法操作的增加变得容易。访问者模式的优点就是增加新的操作很容易。
缺点：使增加新的数据结构变得困难。
Visitor：为该对象结构中的ConcreteElement的每一个类声明一个Visit操作。
ConcreteVisitor:具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分。
Element:定义一个Accept操作，以一个访问者为参数
ConcreteElement:具体元素，实现Accept操作。
ObjectStructure:枚举它的元素，可以提供一个高层的接口以允许访问者访问它的元素

Visitor1.cs

using System;
using System.Collections.Generic;
using System.Text;

//访问者模式（Visitor）：表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素
//的类的前提下定义作用于这些元素的新操作。
//访问者模式的目的是要把处理从数据结构分离出来，当系统有比较稳定的数据结构，又有易于变化的
//算法的话，使用访问者模式就是比较合适的，访问者模式使得算法操作的增加变得容易。访问者模式的
//优点就是增加新的操作很容易。
//缺点：使增加新的数据结构变得困难。
//Visitor：为该对象结构中的ConcreteElement的每一个类声明一个Visit操作。
//ConcreteVisitor:具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分。
//Element:定义一个Accept操作，以一个访问者为参数
//ConcreteElement:具体元素，实现Accept操作。
//ObjectStructure:枚举它的元素，可以提供一个高层的接口以允许访问者访问它的元素
namespace Visitor
{
    class Visitor1
    {
    }
    //Element
    abstract class Element
    {
        public abstract void Accept(Visitor visitor);
    }
    //ConcreteElement
    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() { }
    }
    //Visitor
    abstract class Visitor
    {
        public abstract void VisitConcreteElementA(ConcreteElementA concreteElementA);
        public abstract void VisitConcreteElementB(ConcreteElementB concreteElementB);
    }
    //ConcreteVisitor1
    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);
        }
    }
    //ObjectStructure
    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);
            }
        }
    }
}

 

Program.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace 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();
        }
    }
}

运行结果：

ConcreteElementA被ConcreteVisitor1访问

ConcreteElementB被ConcreteVisitor1访问

ConcreteElementA被ConcreteVisitor2访问

ConcreteElementB被ConcreteVisitor2访问