访问者模式

1. 用了模式实现

这个性别是稳定的，所有可以在状态类中，增加男人反应和女人反应两个方法，方法个数是稳定的，不会很容易的方式变化。

class Program
{
    static void Main(string[] args)
    {
        ObjectStructure o = new ObjectStructure();
        o.Attach(new Man());
        o.Attach(new Woman());

        Success v1 = new Success();
        o.Display(v1);

        Failing v2 = new Failing();
        o.Display(v2);

        Amativeness v3 = new Amativeness();
        o.Display(v3);

        Marriage v4 = new Marriage();
        o.Display(v4);

        Console.Read();
    }
}

//状态
abstract class Action
{
    //得到男人结论或反应
    public abstract void GetManConclusion(Man concreteElementA);
    //得到女人结论或反应
    public abstract void GetWomanConclusion(Woman concreteElementB);
}


//成功
class Success : Action
{
    public override void GetManConclusion(Man concreteElementA)
    {
        Console.WriteLine("{0}{1}时，背后多半有一个伟大的女人。", concreteElementA.GetType().Name, this.GetType().Name);
    }

    public override void GetWomanConclusion(Woman concreteElementB)
    {
        Console.WriteLine("{0}{1}时，背后大多有一个不成功的男人。", concreteElementB.GetType().Name, this.GetType().Name);
    }
}
//失败
class Failing : Action
{
    public override void GetManConclusion(Man concreteElementA)
    {
        Console.WriteLine("{0}{1}时，闷头喝酒，谁也不用劝。", concreteElementA.GetType().Name, this.GetType().Name);
    }

    public override void GetWomanConclusion(Woman concreteElementB)
    {
        Console.WriteLine("{0}{1}时，眼泪汪汪，谁也劝不了。", concreteElementB.GetType().Name, this.GetType().Name);
    }
}
//恋爱
class Amativeness : Action
{
    public override void GetManConclusion(Man concreteElementA)
    {
        Console.WriteLine("{0}{1}时，凡事不懂也要装懂。", concreteElementA.GetType().Name, this.GetType().Name);
    }

    public override void GetWomanConclusion(Woman concreteElementB)
    {
        Console.WriteLine("{0}{1}时，遇事懂也装作不懂", concreteElementB.GetType().Name, this.GetType().Name);
    }
}
//结婚
class Marriage : Action
{
    public override void GetManConclusion(Man concreteElementA)
    {
        Console.WriteLine("{0}{1}时，感慨道：恋爱游戏终结时，‘有妻徒刑’遥无期。", concreteElementA.GetType().Name, this.GetType().Name);
    }

    public override void GetWomanConclusion(Woman concreteElementB)
    {
        Console.WriteLine("{0}{1}时，欣慰曰：爱情长跑路漫漫，婚姻保险保平安。", concreteElementB.GetType().Name, this.GetType().Name);
    }
}

//人
abstract class Person
{
    //接受
    public abstract void Accept(Action visitor);
}

//男人
class Man : Person
{
    public override void Accept(Action visitor)
    {
        visitor.GetManConclusion(this);
    }
}

//女人
class Woman : Person
{
    public override void Accept(Action visitor)
    {
        visitor.GetWomanConclusion(this);
    }
}
//对象结构
class ObjectStructure
{
    private IList<Person> elements = new List<Person>();

    //增加
    public void Attach(Person element)
    {
        elements.Add(element);
    }
    //移除
    public void Detach(Person element)
    {
        elements.Remove(element);
    }
    //查看显示
    public void Display(Action visitor)
    {
        foreach (Person e in elements)
        {
            e.Accept(visitor);
        }
    }
}

双分派:首先在客户程序中将具体状态作为参数传递给男人类完成一次指派，然后男人类调用作为参数的具体状态中的方法'男人反应'，同时将自己的this作为参数传递进去，这便完成第二次指派。双分派意味着得到执行的操作决定与请求的种类和两个接收者的类型。
B: 由于用了双分派，使得我只需要增加一个状态子类，就可以子类客户端调用来查看，不需要改动其他任何类的代码。

2. 访问者模式

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

B: 访问者模式适用于数据结构相对稳定的系统。
A: 它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化。
A: 目的是要把处理从数据结构分离出来。系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式就比较合适的，因为访问者模式使得算法操作的增加变得容易。
B: 访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味这增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。
B: 缺点其实也就是是增加啊新的数据结构变得困难了。

3. 基本代码

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

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