[AYJS] wpf设计模式学习[23]-访问者模式

优点：

1、符合单一职责原则：凡是适用访问者模式的场景中，元素类中需要封装在访问者中的操作必定是与元素类本身关系不大且是易变的操作，使用访问者模式一方面符合单一职责原则，另一方面，因为被封装的操作通常来说都是易变的，所以当发生变化时，就可以在不改变元素类本身的前提下，实现对变化部分的扩展。

2、扩展性良好：元素类可以通过接受不同的访问者来实现对不同操作的扩展

结构图：

角色说明：

1.Visitor 抽象访问者角色，为该对象结构中具体元素角色声明一个访问操作接口。该操作接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色，这样访问者就可以通过该元素角色的特定接口直接访问它。

2.ConcreteVisitor.具体访问者角色，实现Visitor声明的接口。

3.Element 定义一个接受访问操作(accept())，它以一个访问者(Visitor)作为参数。

4.ConcreteElement 具体元素，实现了抽象元素(Element)所定义的接受操作接口。

5.ObjectStructure 结构对象角色，这是使用访问者模式必备的角色。它具备以下特性：能枚举它的元素；可以提供一个高层接口以允许访问者访问它的元素；如有需要，可以设计成一个复合对象或者一个聚集（如一个列表或无序集合）。

适用：

数据结构相对稳定的系统。它把数据结构和作用于结构上的操作之间的偶尔解脱开，使得操作集合可以相对地自由地演化。

AY=============================理解===========

首先确定改对象的行为，这个行为是可以动态增加的。但是多少个对象参加，这个数量要固定。要已知的。不然新增个对象就要新增很多行为什么的。这是不符合开放-封闭原则的。

第一个版本：

 public abstract class Element
    {
        public abstract void Accept(Visitor visitor);
    }
    public class ConcreteElementA : Element
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitConcreteElementA();
        }
        public void OperationA() { }
    }
    public class ConcreteElementB : Element
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitConcreteElementB();
        }
        public void OperationB() { }
    }

A行为，B行为。

创建一个访问者抽象类，然后添加访问者具体的内容

  public abstract class Visitor
    {
        public abstract void VisitConcreteElementA();
        public abstract void VisitConcreteElementB();
    }

到目前内容：

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

namespace StrategyMo.FangWenZhe
{
    public abstract class Element
    {
        public abstract void Accept(Visitor visitor);
    }
    public class ConcreteElementA : Element
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitConcreteElementA(this);
        }
        public void OperationA() { }
    }
    public class ConcreteElementB : Element
    {
        public override void Accept(Visitor visitor)
        {
            visitor.VisitConcreteElementB(this);
        }
        public void OperationB() { }
    }



    public abstract class Visitor
    {
        public abstract void VisitConcreteElementA(ConcreteElementA aa);
        public abstract void VisitConcreteElementB(ConcreteElementB bb);
    }

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

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

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

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


}

添加ObjectStructure角色

  public class ObjectStructure
    {
        private IList<Element> elements = new List<Element>();

        public void Attach(Element ele)
        {
            elements.Add(ele);
        }

        public void Detach(Element ele)
        {
            elements.Remove(ele);
        }

        public void Accept(Visitor visitor)
        {
            foreach (Element e in elements)
            {
                e.Accept(visitor);
            }

        }
    }

客户端:

      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);

效果图：

这个模式跟桥接模式一样复杂，也不怎么常用，有点难度，我是没怎么看懂，晕晕的。

先到这吧，到这里，设计模式已经学完了。

效果：

Element下的所有子类对任何一个Visitor都适用。如果多了1个新的访问者，只要Accept一个就够了，以前的代码不用任何处理。