中介模式（租户—中介—房东）

中介模式（Mediator）：

  用一个中介对象，来封装一系列的对象交互。中介者使个对象不需要显式地相互引用，从而使其耦合松散，并且可以独立地改变他们之间的交互。

一、UML结构图

二、示例代码

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

/*
 * 中介模式：就像租房中介一样
 * 房东，不了解租户信息，但知道中介（Colleague1）
 * 租户：不了解房东信息，但知道中介（Colleague2）
 * 中介：需要知道房东和租户，并在中介做调和。（ConcreteMediator）
 */
namespace 中介者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            //中介者
            Mediator m = new ConcreteMediator();
            //同事1
            Colleague c1 = new ConcreteColleagueA(m);
            //同事2
            Colleague c2 = new ConcreteColleagueB(m);

            m.colleague1=c1;
            m.colleague2=c2;

            c1.Send("你好，我是C1.");
            c2.Send("你好，我是C2.");

            Console.Read();
        }
    }

    /// <summary>
    /// 中介基类
    /// </summary>
    public abstract class Mediator
    {
        /// <summary>
        /// 发送消息(将两个对象间，需要进行的耦合操作行为，进行抽象)
        /// </summary>
        /// <param name="msg">发送的内容</param>
        /// <param name="colleague">发送人</param>
        public abstract void Send(string msg, Colleague colleague);

        public Colleague colleague1 { get; set; }
        public Colleague colleague2 { get; set; }
    }

    public class ConcreteMediator:Mediator
    {

        public override void Send(string msg, Colleague colleague)
        {
            //中介在接收到消息，并发送时，可以对消息进行处理

            //处理后，进行发送
            if (colleague == colleague1)
                colleague2.Notify(msg, colleague);
            else
                colleague1.Notify(msg, colleague);
        }
    }


    /// <summary>
    /// Colleague 同事、同僚
    /// </summary>
    public abstract class Colleague
    {
        protected Mediator m_Mediator;
        public Colleague(Mediator mediator)
        {
            m_Mediator = mediator;
        }

        public abstract void Send(string msg);
        public abstract void Notify(string msg,Colleague sendColleague);

    }

    public class ConcreteColleagueA:Colleague
    {
        public ConcreteColleagueA(Mediator mediator)
            : base(mediator)
        {

        }

        public override void Send(string mes)
        {
            m_Mediator.Send(mes, this);
        }

        public override void Notify(string msg, Colleague sendColleague)
        {
            Console.WriteLine(string.Format("接收到{0}的消息{1}.",sendColleague.ToString(),msg));
        }

        public override string ToString()
        {
            return "ConcreteColleagueA";
        }
    }
    public class ConcreteColleagueB : Colleague
    {
        public ConcreteColleagueB(Mediator mediator)
            : base(mediator)
        {

        }

        public override void Send(string mes)
        {
            m_Mediator.Send(mes, this);
        }
        public override void Notify(string msg, Colleague sendColleague)
        {
            Console.WriteLine(string.Format("接收到{0}的消息{1}.", sendColleague.ToString(), msg));
        }

        public override string ToString()
        {
            return "ConcreteColleagueB";
        }
    }

}

三、作用

优点：

1、减少了各个Colleague的耦合，使其可以独立的改变和复用各个Colleague和Mediator

2、将Colleague对象间的协作进行了抽象，这样关注的对象，就从对象本身转移到了协作交互上来了，角度更为宏观了。

缺点：

1、中介类控制了集中化，于是就把交互复杂性转移到了中介者身上，这就是中介者更为复杂。