2017.01.12 学习日记-中介者模式

好几天没有更新，因为都忙着线性代数和设计模式的考试去了，唉，考的也是一个悲催啊。。。今天继续学习中介者模式。

中介者模式（Mediator Pattern）

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

角色：

Mediator：中介者接口。在里面定义了各个同事之间相互交互所需要的方法，可以是公共的方法，如Change方法，也可以是小范围的交互方法。

ConcreteMediator：具体的中介者实现对象。它需要了解并为维护每个同事对象，并负责具体的协调各个同事对象的交互关系。

Colleague：同事类的定义，通常实现成为抽象类，主要负责约束同事对象的类型，并实现一些具体同事类之间的公共功能，比如，每个具体同事类都应该知道中介者对象，也就是每个同事对象都会持有中介者对象的引用，这个功能可定义在这个类中。

ConcreteColleague：具体的同事类，实现自己的业务，需要与其他同事对象交互时，就通知中介对象，中介对象会负责后续的交互。

类图：

模式代码：

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


 class ConcreteMediator : Mediator
    {
        private ConcreteColleague1 colleague1;

        internal ConcreteColleague1 Colleague1
        {
            set { colleague1 = value; }
        }
        private ConcreteColleague2 colleague2;

        internal 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;
        }
    }


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);
        }
    }


class Program
    {
        static void Main(string[] args)
        {
            ConcreteMediator cm = new ConcreteMediator();
            ConcreteColleague1 c1 = new ConcreteColleague1(cm);
            ConcreteColleague2 c2 = new ConcreteColleague2(cm);

            cm.Colleague1 = c1;
            cm.Colleague2 = c2;

            c1.Send("吃饭了吗？");
            c2.Send("没有呢，你打算请客？");

            Console.ReadKey();
        }
    }

可以看出，中介对象主要是用来封装行为的，行为的参与者就是那些对象，但是通过中介者，这些对象不用相互知道。

优点：

1.降低了系统对象之间的耦合性，使得对象易于独立的被复用。

2.提高系统的灵活性，使得系统易于扩展和维护。

缺点：

因为这个“中介“承担了较多的责任，所以一旦这个中介对象出现了问题，那么整个系统就会受到重大的影响。