中介者模式（Mediator Pattern）

中介者模式（Mediator Pattern）
用一个中介者对象来封装一系列对象交互。中介者使得各对象不需要相互引用，从而使其耦合松散，而且可以
独立的改变它们之间的交互。

依赖关系的转化

 

动机(Motivate):
     在软件构建过程中，经常会出现多个对象互相关联交互的情况，对象之间常常会维持一种复杂的引用关系，
  如果遇到一些需求的更改，这种直接的引用关系将面临不断的变化。
    在这种情况下，我们可使用一个“中介对象”来管理对象间的关联关系，避免相互交互的对象之间的紧耦合引用关系，
 从而更好地抵御变化。

适用性：
    1.一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。
    2.一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象。
    3.想定制一个分布在多个类中的行为，而又不想生成太多的子类。

 

/// <summary>
    /// 抽象中介者类，定义一个抽象的发送消息方法，得到同事对象和 发送消息
    /// </summary>
    abstract class Mediator
    {
        public abstract void Send(string message, Colleague colleague);
    }

    /// <summary>
    /// 具体的中介者类
    /// 需要了解所有的具体同事类
    /// </summary>
    class ConcreteMediator : Mediator
    {
        private ConcreteColleague1 colleague1;

        internal ConcreteColleague1 Colleague1
        {
            get { return colleague1; }
            set { colleague1 = value; }
        }
        private ConcreteColleague2 colleague2;

        internal ConcreteColleague2 Colleague2
        {
            get { return colleague2; }
            set { colleague2 = value; }
        }

        public override void Send(string message, Colleague colleague)
        {
            //如果是同事1要发送消息，则同事2接收
            if (colleague == colleague1)
            {
                colleague2.Notify(message);
            }
            else
            {
                colleague1.Notify(message);
            }
        }
    }

    /// <summary>
    /// 抽象同事类，认识中介者
    /// </summary>
    abstract class Colleague
    {
        protected Mediator mediator;

        //得到中介者对象
        public Colleague(Mediator mediator)
        {
            this.mediator = mediator;
        }
    }

    /// <summary>
    /// 具体的同事类
    /// 每个具体的同事只知道自己的行为，而不了解其他同事的情况，但它们都认识中介者对象
    /// 同事之间的通信可以通过中介者传递
    /// </summary>
    class ConcreteColleague1 : Colleague
    {
        public ConcreteColleague1(Mediator mediator)
            : base(mediator)
        { }

        /// <summary>
        /// 发送消息时都是通过中介着发送出去的
        /// 自己本身并不与其他同事类通信
        /// </summary>
        /// <param name="message"></param>
        public void Send(string message)
        {
            mediator.Send(message, this);
        }

        public void Notify(string message)
        {
            Console.WriteLine("同事1得到消息:"+message);
        }
    }

    class ConcreteColleague2 : Colleague
    {
        public ConcreteColleague2(Mediator mediator)
            : base(mediator)
        { }

        /// <summary>
        /// 发送消息时都是通过中介着发送出去的
        /// 自己本身并不与其他同事类通信
        /// </summary>
        /// <param name="message"></param>
        public void Send(string message)
        {
            mediator.Send(message, this);
        }

        public void Notify(string message)
        {
            Console.WriteLine("同事2得到消息:" + message);
        }
    }

    public class Program
    {
        public static void Main()
        {
            //定义中介者
            ConcreteMediator mediator = new ConcreteMediator();

            //让每个同事类都认识中介者
            ConcreteColleague1 c1 = new ConcreteColleague1(mediator);
            ConcreteColleague2 c2 = new ConcreteColleague2(mediator);

            //让中介者认识各个具体同事类
            mediator.Colleague1 = c1;
            mediator.Colleague2 = c2;

            c1.Send("吃了吗您呢？");
            c2.Send("没呢，你打算请客吗？");
        }
    }