设计模式之访问者模式(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访问