大话设计模式:中介模式

一、什么是中介模式

封装一组对象的耦合交互

像是一个调停者,将大家的意见聚拢到一起,然后统一安排。解除对象之间复杂的耦合，允许他们独立变化。

UML图

Mediator:抽象中介类,有一个处理交互的方法
ConcreteMediator: 具体中介类,持有所有同事类,并根据情况来发布消息
Colleague: 抽象同事类,需要确定中介是谁
ConcreteColleagueA:具体同事类,具备行为和反应

二、适用场景

如果一个系统对象，存在很多多对多的关系，将导致关系极其复杂，这些对象可以称之为同时对象，我们可以引入中介对象，让同事对象只与中介对象打交道，将同事之间的关系进行分离和封装。中介模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合。
比如计算机Form框架，web页面aspx，以及想定制一个分布在多个类中的行为。

三、优缺点

优点
一组多对多的对象解耦合,降低系统复杂程度
系统扩展和修改都比较方便,操作某个类不会对其它类造成影响

缺点
系统过于庞大将导致中介类过于复杂,违背单一职责 原则

四、大话中的例子

联合国对各国事宜的调停,一个联合国抽象类,里面有对成员国的操作方法, 具体的安理会,关联美国,伊拉克, 并根据传递过来的消息,实行消息分发.美国和伊拉克都是成员国,依赖联合国,有什么问题就发给安理会,安理会会根据发送发和内容传达。

五、我的例子

using System;
using System.Collections.Generic;


namespace MediatorMode
{
    class Program
    {
        static void Main(string[] args)
        {
            Akatsuki akatsuki = new Akatsuki();
            Deidara deidara = new Deidara(akatsuki);
            kisame kisame = new kisame(akatsuki);
            Itachui itachui = new Itachui(akatsuki);
            akatsuki.Members.Add(deidara);
            akatsuki.Members.Add(kisame);
            akatsuki.Members.Add(itachui);
            deidara.CaptureTailed();
            kisame.CaptureTailed();
            Console.ReadKey();
        }
    }

    /// <summary>
    /// 晓组织
    /// </summary>
    class Akatsuki
    {
        List<AkatsukiMember> members = new List<AkatsukiMember>();//成员

        internal List<AkatsukiMember> Members { get => members; set => members = value; }


        /// <summary>
        /// 接收并发布消息
        /// </summary>
        /// <param name="member"></param>
        /// <param name="message"></param>
        public void CollectTailBeast(AkatsukiMember member, String message)
        {
            Console.WriteLine("{0}抓到{1}了,大家快来.", member.GetType().Name, message);
            foreach (var item in members)
            {
                item.SealTailed(message);
            }
        }
    }

    /// <summary>
    /// 晓组织成员
    /// </summary>
    abstract class AkatsukiMember
    {
        protected Akatsuki akatsuki;
        public AkatsukiMember(Akatsuki akatsuki)
        {
            this.akatsuki = akatsuki;
        }
        /// <summary>
        /// 捕获尾兽
        /// </summary>
        public abstract void CaptureTailed();

        /// <summary>
        /// 封印尾兽
        /// </summary>
        /// <param name="messgae"></param>
        public void SealTailed(string messgae)
        {
            Console.WriteLine("{0}参与封印{1}", GetType().Name, messgae);
        }
    }

    /// <summary>
    /// 迪达拉
    /// </summary>
    class Deidara : AkatsukiMember
    {
        public Deidara(Akatsuki akatsuki) : base(akatsuki)
        {
        }

        public override void CaptureTailed()
        {
            akatsuki.CollectTailBeast(this, "一尾守鹤");
        }


    }

    /// <summary>
    /// 鬼鲛
    /// </summary>
    class kisame : AkatsukiMember
    {
        public kisame(Akatsuki akatsuki) : base(akatsuki)
        {
        }

        public override void CaptureTailed()
        {
            akatsuki.CollectTailBeast(this, "四尾孙悟空");
        }

    }

    /// <summary>
    /// 鼬
    /// </summary>
    class Itachui : AkatsukiMember
    {
        public Itachui(Akatsuki akatsuki) : base(akatsuki)
        {
        }

        public override void CaptureTailed()
        {

        }
    }
}

运行结果

PS：中介模式不可滥用,容易造成系统混乱,和中介类过于庞大.把对象如何协作进行了抽象,将中介作为一个独立的概念并将其封装在一个对象中,这样关注的对象就从对象各自本身的行为转移到他们之间的交互上来,也就是站在一个更宏观的角度去看待系统。