设计模式二十四讲之《中介者模式》

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

应用前提：尽管将一个系统分割成许多对象通常可以增加其可复用性，但是对象间相互连接的激增又会降低其可复用性，因为大量的连接使得一个对象不可能在没有其他对象的支持下工作，系统表现为一个不可分割的整体，所以，对系统的行为进行任何较大的改动就十分困难了。中介者模式很容易在系统中应用，也很容易在系统中误用。但系统出现了‘多对多’交互复杂的对象群时，不要急于使用中介者模式，而要先反思你的系统在设计上是不是合理。

优点：1.Mediator的出现减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator；2.由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身行为转移到它们之间的交互上来，也就是站在一个更宏观的角度去看待系统。

缺点：由于ConcreteMediator控制了集中化，于是就把交互复杂性变为了中介者的复杂性，这就使得中介者会变得比任何一个ConcreteColleague都复杂。

应用时机：一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在多个类中的行为，而又不想生成太多的子类的场合，比如游戏中的不同UI界面之间要交互需用UIManager来控制。

提示：尽管将一个系统分割成许多对象通常可以增加其可复用性，但是对象间相互通信的激增又会降低其可复用性，因为大量的连接使得一个对象不可能在没有其他对象支持下工作，系统表现为一个不可分割的整体，所以，对系统的行为进行任何较大的改动就十分困难了。

---

 class Program
    {
        static void Main(string[] args)
        {
            //ConcreteMediator m = new ConcreteMediator();    //不带例子的中介者模式写法                                     //执行步骤：1.申明ConcreteMediator对象；
                                                                                                                         //          2.声明继承于Colleague的ConcreteColleague1和ConcreteColleague2对象，并将ConcreteMediator传递进自身的mediator；
            //Colleague c1 = new ConcreteColleague1(m);                                                                      //          3.将ConcreteColleague1属性传递到ConcreteMediator中Colleague1上（第二个ConcreteColleague1一样），用于后面的判断；
            //Colleague c2 = new ConcreteColleague2(m);                                                                      //          4.ConcreteColleague1和ConcreteColleague2调用Send方法，并进入ConcreteMediator中判断调用。

            //m.Colleague1 = (ConcreteColleague1)c1;//    这里因为ConcreteMediator中的Colleague1是ConcreteColleague1类的，而
            //                                      //c1的实质对象是ConcreteColleague1，但外包装是Colleague，所以必须要一个
            //                                      //显示转换，或者直接将c1的外包装改为ConcreteColleague1。
            //m.Colleague2 = (ConcreteColleague2)c2;
            //c1.Send("吃过饭了吗？");
            //c2.Send("没有，你打算请客？");
            //Console.Read();


            UnitedNationsSecurityCouncil UNSC = new UnitedNationsSecurityCouncil();   //带例子的中介者模式写法              //执行步骤：1.申明UnitedNationsSecurityCouncil对象；
            USA c1 = new USA(UNSC);                                                                                         //          2.虽然USA和Irap都继承于Country类，但这里暂时不考虑继承多态表示，而是为了方便后面调用，直接申明对象，并将
            Iraq c2 = new Iraq(UNSC);                                                                                       //            UnitedNationsSecurityCouncil作为参数构造传递给c1/c2对象中的mediator，用于执行UniteNations的Declare方法；
            UNSC.Colleague1 = c1;                                                                                           //          3.将USA和Iraq属性传递到UnitedNationsSecurityCouncil中Colleague1和Colleague2上，用于后面判断；
            UNSC.Colleague2 = c2;                                                                                           //          4.USA和Iraq调用Declare方法，并进入UnitedNationsSecurityCouncil中判断调用。
            c1.Declare("不准研制泡泡糖，否则亲亲你");
            c2.Declare("我们没有泡泡糖，也不怕亲亲");
            Console.Read();

        }
    }

---

 abstract  class UniteNations
    {
        public abstract void Declare(string message,Country colleague);
    }

    class UnitedNationsSecurityCouncil : UniteNations
    {
        private USA colleague1;
        private Iraq colleague2;
        public USA Colleague1
        {
            set { colleague1 = value; }
        }
        public Iraq Colleague2
        {
            set { colleague2 = value; }
        }
        public override void Declare(string message, Country colleague)
        {
          if(colleague==colleague1)
            {
                colleague2.GetMessage(message);
            }
            else
            {
                colleague1.GetMessage(message);
            }
        }
    }

---

 abstract class Country
    {
        protected UniteNations mediator;
        public Country(UniteNations mediator)
        {
            this.mediator = mediator;
        }
        public abstract void Declare(string message);
        public abstract void GetMessage(string message);
      }

    class USA : Country
    {
        public USA(UniteNations mediator) : base(mediator)
        {
        }

        public override void Declare(string message)
        {
            mediator.Declare(message, this);
        }

        public override void GetMessage(string message)
        {
            Console.WriteLine("美国获得对方信息："+message );
        }
    }
    class Iraq : Country
    {
        public Iraq(UniteNations mediator) : base(mediator)
        {
        }

        public override void Declare(string message)
        {
            mediator.Declare(message, this);
        }

        public override void GetMessage(string message)
        {
            Console.WriteLine("伊朗获得对方信息：" + message);
        }
    }

---

abstract class Mediator
    {
        public abstract void Send(string message, Colleague colleague);
    }

    class ConcreteMediator : Mediator
    {
        private ConcreteColleague1 colleague1;
        private ConcreteColleague2 colleague2;
        private Colleague colleagueTest;
        public Colleague ColleagueTest
        {
            set { colleagueTest = value; }
        }

        public ConcreteColleague1 Colleague1
        {
            set { colleague1 = value; }
        }
        public ConcreteColleague2 Colleague2
        {
            set { colleague2 = value; }
        }
        public override void Send(string message, Colleague colleague)
        {
            if (colleague == colleague1)
            {
                colleague2.Notify(message);
            }
            else
            {
                colleague1.Notify(message);
            }
        }
    }

---

abstract class Colleague
    {
        protected Mediator mediator;
        public Colleague (Mediator mediator)
        {
            this.mediator = mediator;
        }
       public  abstract void Send(string message);
    }
    class ConcreteColleague1 : Colleague
    {
        public ConcreteColleague1(Mediator mediator) : base(mediator)
        {
        }
        public override  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)
        {
        }
        public override void Send(string message)
        {
            mediator.Send(message, this);
        }
        public void Notify(string message)
        {
            Console.WriteLine("同事2得到消息：" + message);
        }
    }

转载请注明出处!!!

欢迎加入951815219群聊，共享知识，讨论交流~