定义：（Mediator Pattern）

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

类图：

启示：

最近两年，楼市疯狂，房价涨的离谱。为了预防楼市泡沫，中央出台一项项政策进行调控。在这样一个现实场景中，共有三个角色，买房者，房地产商，住建局。
买房者关注房地厂商的楼盘及房价，决定是否买房；
房地厂商关注买方市场，是否需要新建楼盘；
住建局就来协调买方与卖方市场，限购限建。
三个角色相互依赖，相互交互。耦合性比较紧，如何来解耦呢？中介者来帮忙。
中介是谁呢？就像你去买房，你肯定找中介啊，中介无所不知，他们即知道房地厂商有哪些楼盘，又了解买房市场的需求，同时也很熟悉国家的楼市政策。

代码：

/// <summary>
    /// 抽象角色（模块）
    /// 主要实现中介的依赖注入
    /// </summary>
    public abstract class Role
    {
        protected AbstractMediator mediator;

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

 /// <summary>
    /// 购房（者）市场
    /// </summary>
    public class HomeBuyer : Role
    {
        private readonly string name = "购房市场：";
        public HomeBuyer(AbstractMediator mediator)
            : base(mediator)
        {

        }
        private static int requirement = 800;//购房需求

        public void BuyHouse(int num)
        {
            string rule = mediator.GetRule();

            Console.WriteLine(name + "需要买房：" + num + "套");

            if (rule != "LimitBuy")
            {
                requirement += num;
            }
            else
            {
                Console.WriteLine(name + "国家实例了限购政策，不允许购买");
            }
        }

        /// <summary>
        /// 签订购房合同
        /// </summary>
        /// <param name="num"></param>
        public void SignAgreement(int num)
        {
            requirement -= num;
            Console.WriteLine(string.Format("{0}成功购房{1}套", name, num));
        }

        public int GetRequirement()
        {
            return requirement;
        }
    }

 /// <summary>
    /// 房地产商
    /// </summary>
    public class Builder : Role
    {
        private readonly string name = "房地产商：";
        public Builder(AbstractMediator mediator)
            : base(mediator)
        {

        }

        private static int houseNum = 1000;

        public void BuildHouse()
        {
            int requirement = mediator.GetBuyRequirement();
            if (houseNum < requirement)
            {
                //房源不够，立马新建
                int needBuild = requirement - houseNum + 100;
                Console.WriteLine(name + "建房：" + needBuild + "套");
                houseNum += needBuild;
            }
        }

        public void SaleHouse(int num)
        {
            if (houseNum < num)
            {
                string rule = mediator.GetRule();

                if (rule != "LimitBuild")
                {
                    Console.WriteLine(name + "房源不够，正在建设中");
                    this.BuildHouse();
                }
            }
            else
            {
                houseNum -= num;
                Console.WriteLine(name + "卖房：" + num + "套");
                //告诉购房者签订合同
                mediator.HomeBuyer.SignAgreement(num);
            }
        }

        public int ShowHouseNum()
        {
            return houseNum;
        }
    }

   /// <summary>
    /// 住建局
    /// </summary>
    public class ControlCenter : Role
    {
        public ControlCenter(AbstractMediator mediator)
            : base(mediator)
        {

        }
        private readonly string name = "住建局：";
        private static string rule;

        /// <summary>
        /// 当需大于供，限购
        /// 当供大于需，限建
        /// </summary>
        public void Limit()
        {
            int requirement = mediator.GetBuyRequirement();
            int buildingNum = mediator.GetCurrentHouseNumber();

            string strs = string.Format("{0}目前购房需求为：{1}套;现有房源：{2}套。", name,requirement, buildingNum);

            if (requirement > buildingNum)
            {
                Console.WriteLine(strs + "供小于需，开始实施限购政策");
                rule = "LimitBuy";
            }
            else
            {
                Console.WriteLine(strs + "供大于需，开始实施限建政策");
                rule = "LimitBuild";
            }
        }

        public string ShowRule()
        {
            return rule;
        }

/// <summary>
    /// 抽象中介，定义各模块依赖的功能
    /// </summary>
    public abstract class AbstractMediator
    {
        /// <summary>
        /// 使用属性注入
        /// 因为中介可能只需要和部分角色（模块）交互
        /// </summary>
        public HomeBuyer HomeBuyer { get; set; }
        public Builder HouseBuilder { get; set; }
        public ControlCenter ControlCenter { get; set; }

        /// <summary>
        /// 获取购房需求
        /// </summary>
        /// <returns></returns>
        public abstract int GetBuyRequirement();

        /// <summary>
        /// 获取房源数目
        /// </summary>
        /// <returns></returns>
        public abstract int GetCurrentHouseNumber();

        /// <summary>
        /// 获取楼市政策
        /// </summary>
        /// <returns></returns>
        public abstract string GetRule();

    }

    /// <summary>
    /// 具体中介，实现各模块依赖的功能
    /// </summary>
    public class Mediator : AbstractMediator
    {
        public override int GetBuyRequirement()
        {
            return base.HomeBuyer.GetRequirement();
        }

        public override int GetCurrentHouseNumber()
        {
            return base.HouseBuilder.ShowHouseNum();
        }

        public override string GetRule()
        {
            return base.ControlCenter.ShowRule();
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            AbstractMediator mediator = new Mediator();

            //声明参与的角色
            HomeBuyer buyer = new HomeBuyer(mediator);
            Builder build = new Builder(mediator);
            ControlCenter center = new ControlCenter(mediator);

            //将需要的角色注入到中介
            mediator.HouseBuilder = build;
            mediator.HomeBuyer = buyer;
            mediator.ControlCenter = center;

            int initRequirement = mediator.GetBuyRequirement();
            int initHousenum = mediator.GetCurrentHouseNumber();

            Console.WriteLine(string.Format("目前购房需求为：{0}套;现有房源：{1}套。", initRequirement, initHousenum));

            //买房300套
            buyer.BuyHouse(300);
            
            build.SaleHouse(300);            

            //国家住建局，考察市场
            center.Limit();

            //再买房1000套
            buyer.BuyHouse(1000);

            Console.ReadLine();
        }
    }

参与角色：

● Mediator 抽象中介者角色
抽象中介者角色定义统一的接口，用于各同事角色之间的通信。
● Concrete Mediator 具体中介者角色
具体中介者角色通过协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。
● Colleague 同事角色
每一个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。每个同事类的行为分为两种：一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等，这种行为叫做自发行为（Self-Method），与其他的同事类或中介者没有任何的依赖；第二种是必须依赖中介者才能完成的行为，叫做依赖方法（Dep-Method）。

优缺点：

优点：中介者模式的优点就是减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖，同事类只依赖中介者，减少了依赖，当然同时也降低了类间的耦合
缺点：中介者模式的缺点就是中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。

应用场景：

当类图中出现了蜘蛛网状结构时一定要考虑使用中介者模式，这有利于把蜘蛛网梳理为星型结构，使原本复杂混乱的关系变得清晰简单。

源码：

源代码C#

系列导航：

目录