设计模式学习笔记-中介模式

概述：                                                                                                       

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

适用场合：                                                                                                 

1.一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。

2.一个对象引用很多其他对象并直接与这些对象通信，导致难以复用该对象。

3.想定制一个分部在多个类中的行为，而又不想生成太多的子类。

类图：                                                                                                      

示例代码：                                                                                                 

1.定义抽象中介者类

    /// <summary>
    /// 抽象中介者类
    /// </summary>
    abstract  class Mediator
    {
        /// <summary>
        /// 得到同事对象和发送消息的抽象方法
        /// </summary>
        /// <param name="message"></param>
        /// <param name="colleague"></param>
        public abstract void Send(string message,Colleague colleague);
    }

2.定义抽象同事类

    /// <summary>
    /// 抽象同事类
    /// </summary>
   abstract  class Colleague
    {
       protected Mediator mediator;
       /// <summary>
       /// 初始化中介者对象
       /// </summary>
       /// <param name="mediator"></param>
       public Colleague(Mediator mediator) 
       {
           this.mediator = mediator;
       }
    }

3.具体中介者

   /// <summary>
    /// 具体中介者
    /// </summary>
    class ConcreteMediator:Mediator
    {
        private ConcreteColleague1 colleague1;

        private ConcreteColleague2 colleague2;

        public ConcreteColleague1 Colleague1 
        {
            set { colleague1 = value; }
        }
        public ConcreteColleague2 Colleague2 
        {
            set { colleague2 = value; }
        }
        /// <summary>
        /// 重写发送信息的方法，根据所传对象发送到指定对象消息
        /// </summary>
        /// <param name="message"></param>
        /// <param name="colleague"></param>
        public override void Send(string message, Colleague colleague)
        {
            if (colleague == colleague1)
            {
                //同事1给同事2消息
                colleague2.Notify(message);
            }
            else 
            {
                //同事2给同事1消息
                colleague1.Notify(message);
            }
        }
    }

3.具体2个同事

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

4.客户端调用

        /// <summary>
        /// 测试中介者模式
        /// </summary>
        static void TestMediator() 
        {
            ConcreteMediator m = new ConcreteMediator();

            ///让两个具体同事类认识中介者
            ConcreteColleague1 c1 = new ConcreteColleague1(m);
            ConcreteColleague2 c2 = new ConcreteColleague2(m);

            ///让中介者认识具体对象
            m.Colleague1 = c1;
            m.Colleague2 = c2;

            Console.WriteLine("同事1发送消息给同事2");
            c1.Send("吃饭了没?");
            Console.WriteLine("同事2回消息给同事1");
            c2.Send("没呢，你打算请客?");

            Console.Read();
        }

小结：                                                                                                       

中介者模式是将类之间的交互关系抽象出来了，根据场合的复杂度适当选用中介者模式。