包装一系列对象相互作用的方式，使这些对象不必互相明显引用。
调停者模式包括的对象
1、抽象调停者：定义同事（Colleague）对象到调停者（Mediatior）对象的接口，通常是一个事件方法。
2、具体调停者：具体调停者实现抽象调停者声明的方法。知晓所有的具体同事类，从具体同事接收消息向
另外的具体同事类发送命令。
3、抽象同事类：定义调停者到同事对象的接口，同事对象只知道调停者而不知道其他同事对象。

调停者模式的优点
1、将多对多的关系转化为一对多的关系，使对象之间的关系更易于维护。
2、将对象的行为和协作抽象化。
缺点
虽然降低了同事类的复杂性但增加了调停者对象的复杂性。
同事类的复用性是以调停者类的不可复用为代价的。

using System;

namespace DesignPattern.Mediator
{
    public abstract class AbstractMediator
    {
        public abstract void ColleagueChanged(AbstractColleague ac);
    }

    public abstract class AbstractColleague
    {
        private AbstractMediator mediator;

        public AbstractColleague(AbstractMediator mediator)
        {
            this.mediator=mediator;
        }

        public AbstractMediator Mediator
        {
            get{return this.mediator;}
        }

        public abstract void Action();

        public void Change()
        {
            this.mediator.ColleagueChanged(this);
        }
    }

    public class ConcreteMediator : AbstractMediator
    {
        private ColleagueA colleagueA;
        private ColleagueB colleagueB;

        public override void ColleagueChanged(AbstractColleague ac)
        {
            this.colleagueA.Action();
            this.colleagueB.Action();
        }

        public void CreateConcreteMediator()
        {
            this.colleagueA=new ColleagueA(this);
            this.colleagueB=new ColleagueB(this);
        }

        public ColleagueA ColleagueA
        {
            get{return this.colleagueA;}
        }

        public ColleagueB ColleagueB
        {
            get{return this.colleagueB;}
        }
    }

    public class ColleagueA : AbstractColleague
    {
        public ColleagueA(AbstractMediator mediator):base(mediator){}

        public override void Action()
        {
            Console.WriteLine("Action From ColleagueA");
        }
    }

    public class ColleagueB : AbstractColleague
    {
        public ColleagueB(AbstractMediator mediator):base(mediator){}

        public override void Action()
        {
            Console.WriteLine("Action From ColleagueB");
        }
    }

    public class Client
    {
        public static void Main()
        {
            ConcreteMediator cm=new ConcreteMediator();
            cm.CreateConcreteMediator();
            AbstractColleague c1=cm.ColleagueA;
            AbstractColleague c2=cm.ColleagueB;
            //Java与模式的写法我怀疑有错误
            //AbstractColleague c2=new ColleagueB(cm);
            cm.ColleagueChanged(c1);

        }
    }

}