中介者模式

定义

在多对象交互业务中，引入统一业务处理的第三方，实现对象间的解耦。

类图

类图中包含者未引入中介者模式的方法，详情请看代码

代码

    /// <summary>
    /// 房子管理者
    /// </summary>
    public abstract class HouseManger
    {
        protected int moneyCount = 0;
        public string Name { get; set; }
        public HouseManger(string name, int moneyCount)
        {
            this.moneyCount = moneyCount;
            this.Name = name;
        }
        public abstract void Deal(int money, bool flag);
    }
    /// <summary>
    /// A类管理者
    /// </summary>
    public class HouseManagerA : HouseManger
    {
        public HouseManagerA(string name, int money)
            : base(name, money)
        {

        }
        public override void Deal(int money, bool flag)
        {
            moneyCount = flag ? moneyCount + money : moneyCount - money;
        }
        #region 不走中介的模式，增加了对HouseManagerB的强引用
        /// <summary>
        /// 卖房子
        /// </summary>
        /// <param name="money"></param>
        /// <param name="buyer"></param>
        public void Sell(int money, HouseManagerB buyer)
        {
            moneyCount += money;
            Console.WriteLine("将房产正转置{0}名下", buyer.Name);
            buyer.Buy(money, this);

        }
        /// <summary>
        /// 买房子
        /// </summary>
        /// <param name="money"></param>
        /// <param name="seller"></param>
        public void Buy(int money, HouseManagerB seller)
        {
            moneyCount -= money;
            Console.WriteLine("买到{0}的房子了", seller.Name);
        }
        #endregion
    }
    /// <summary>
    /// B类管理者
    /// </summary>
    public class HouseManagerB : HouseManger
    {
        public HouseManagerB(string name, int money = 500000)
            : base(name, money)
        {

        }
        public override void Deal(int money, bool flag)
        {
            moneyCount = flag ? moneyCount + money : moneyCount - money;
        }
        #region 不走中介的模式，增加了对HouseManagerA的强引用，走中介则不会
        /// <summary>
        /// 买房子
        /// </summary>
        /// <param name="money"></param>
        /// <param name="seller"></param>
        public void Buy(int money, HouseManagerA seller)
        {
            moneyCount -= money;
            Console.WriteLine("买到{0}的房子了", seller.Name);
        }
        /// <summary>
        /// 卖房子
        /// </summary>
        /// <param name="money"></param>
        /// <param name="buyer"></param>
        public void Sell(int money, HouseManagerA buyer)
        {
            moneyCount += money;
            Console.WriteLine("将房产正转置{0}名下", buyer.Name);
            buyer.Buy(money, this);

        }
        #endregion

    }
    public abstract class HouseMediator
    {
        protected HouseManagerA a;
        protected HouseManagerB b;
        public HouseMediator(HouseManagerA a, HouseManagerB b)
        {
            this.a = a;
            this.b = b;
        }
        /// <summary>
        /// A卖与B
        /// </summary>
        public abstract void AToBDeal(int money);
        /// <summary>
        /// B卖与A
        /// </summary>
        public abstract void BToADeal(int money);
    }
    /// <summary>
    /// 免费的中介者（房产中介是收钱的，相当于引入新业务，此处只是说明中介者模式）
    /// </summary>
    public class FreeHouseMediator : HouseMediator
    {

        public override void AToBDeal(int money)
        {
            this.a.Deal(money, true);
            this.b.Deal(money, false);
            Console.WriteLine("{0}将房子卖与了{1}", a.Name, b.Name);
        }

        public override void BToADeal(int money)
        {
            this.b.Deal(money, true);
            this.a.Deal(money, false);
            Console.WriteLine("{0}将房子卖与了{1}", b.Name, a.Name);
        }
    }

总结

中介者模式解耦对象之间的强引用，将通知通信交互的业务抽取到中介中来，实现解耦。现实中有很多例子，例如通过微信群进行同学之间信息的通知，微信群就成了一个消息转发的中介。不过自己觉得反而在实际的编程中用的却不是很多。