设计模式深入学习--Mediator 中介者模式(行为型模式)

   今天我们来介绍下Mediator 中介者模式。Interpreter 解释器模式是一种我们游戏设计中大量会用到的设计模式，中介者模定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立地改变它们之间的交互行为。我们先来看基本代码来了解下实现的原理。

/// <summary>
/// Mediator类，抽象中介者类
/// </summary>
abstract class Mediator
{
    public abstract void Send(string message, Colleague colleague);
}
 
 
/// <summary>
/// Colleague类 抽象同事类
/// </summary>
abstract class Colleague
{
    protected Mediator mediator;
 
    public Colleague(Mediator mediator)
    {
        this.mediator = mediator;
    }
}
 
/// <summary>
/// 实体中介者类
/// </summary>
class ConcreteMediator : Mediator
{
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;
 
    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);
        }
    }
}
 
 
/// <summary>
/// 实体同事类1
/// </summary>
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);
    }
}
 
/// <summary>
/// 实体同事类2
/// </summary>
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);
    }
}

   代码中看到，我们先构造了两个虚拟类，一个 Mediator抽象者中介类，一个Colleague抽象者同事类，抽象者中介类有一个send方法，有一个 Colleague 抽象者同事类参数， 抽象同事类包含一个抽象者中介类的引用。再构造两个实体同事类，继承自 Colleague 抽象同事类，这里我们就代表两个具体的人，各自有发送和接收方法，  然后我们在构造一个实体中介类 ConcreteMediator ，继承自 Mediator，该类用来管理我们的抽象者同事类派生的子类实体同事类，所以这个实体中介类包含两个实体同事类引用，处理的逻辑就是 把1发送的内容发给2，或者2的内容发送给1。 好，现在看看跑起来的代码：

{
            ConcreteMediator m=new ConcreteMediator();
 
            ConcreteColleague1 c1=new ConcreteColleague1(m);
            ConcreteColleague2 c2=new ConcreteColleague2(m);
 
            m.Colleague1 = c1;
            m.Colleague2 = c2;
 
            c1.Send("土豆土豆，我是地瓜");
            c2.Send("土豆收到，地瓜请讲");
 
            Console.ReadKey();

   我们声明一个实体中介类m，再声明两个实体同事类c1 c2，都把m传入，然后设置一下让中介者m管理c1和c2 ，然后调用c1的send方法，然后c2 就收到了， 再让c2发送消息，c1也收到了。  


   Mediator 中介者模式的基本原理就是这样，前面的一些声明我们做在游戏的启动部分，后面调用起来 只需要绑定好需要用到的中介者，就可以很好的解除游戏中的 各个部分之间的耦合性，而需要改的仅仅是具体中介者的逻辑。 然后我们再来做一个我们游戏开发常用的MVC的中介者，让中介者来各自调用MVC部分，各自不影响，不关联。

abstract class Manager
{
    public abstract void Notify(string message, Module colleague);
}
 
 
 
abstract class Module
{
    protected Manager mediator;
 
    public Module(Manager mediator)
    {
        this.mediator = mediator;
    }
}
 
//Model 模型数据层
class ModelModule:Module
{
    public ModelModule(Manager mediator) : base(mediator)
    {
 
    }
 
    //通知
    public void Notify(string message)
    {
        mediator.Notify(message,this);
    }
 
    //获得消息
    public void GetMessage(string message)
    {
        Console.WriteLine("Model层收到消息:"+message);
    }
}
 
//View 视图数据层
class ViewModule : Module
{
    public ViewModule(Manager mediator) : base(mediator)
    {
 
    }
 
    //通知
    public void Notify(string message)
    {
        mediator.Notify(message, this);
    }
 
    //获得消息
    public void GetMessage(string message)
    {
        Console.WriteLine("View层收到消息:" + message);
    }
}
 
//Controller 视图数据层
class ControllerModule : Module
{
    public ControllerModule(Manager mediator) : base(mediator)
    {
 
    }
 
    //通知
    public void Notify(string message)
    {
        mediator.Notify(message, this);
    }
 
    //获得消息
    public void GetMessage(string message)
    {
        Console.WriteLine("Controller层收到消息:" + message);
    }
}
 
 
 
class MVCManager : Manager
{
    public  ModelModule m;
    public ViewModule v;
    public ControllerModule c;
 
 
 
 
    public override void Notify(string message, Module colleague)
    {
        if (colleague == c)
        {
            m.GetMessage(message);
            v.GetMessage(message);
        }
    }
}

   首先声明两个虚拟类 一个 Manager管理中介类，一个Module 模型类， 然后声明三个Module模型类的子类，分别是M,V,C ，各自实现父类通知方法，也都有一个 接收信息的方法。  然后声明一个MVCManager类，继承自 Manager 管理中介类，用来处理收发信息的逻辑，这里我们就写个简单的Controller 层向 Model层和View层发送消息的逻辑。好了，然后我们看看跑起来的代码。 

//声明中介对象
    MVCManager mvc=new MVCManager();
    //声明三个同事类，把中介类传入
    ModelModule model=new ModelModule(mvc);
    ViewModule view=new ViewModule(mvc);
    ControllerModule controller=new ControllerModule(mvc);
    //中介类绑定操作对象
    mvc.m = model;
    mvc.c = controller;
    mvc.v = view;
 
    controller.Notify("Conrtroller发送了消息");
 
    Console.ReadKey();

注释我也解释得很清楚了，我们运行看看效果：

   看是不是很简单呢，而且前面主要注册了以后，后面的消息收发都变得非常方便， 很多游戏框架都是用的这样的消息收发机制，底层原理基本就是用的中介者模式，
   在深化改下，就可以做一个个人的小型框架。(对自己说一声: 呵呵)。
   看看使用中介者模式的场合和优缺点：
   使用终结者模式的场合
      1.一组定义良好的对象，现在要进行复杂的通信。
      2.定制一个分布在多个类中的行为，而又不想生成太多的子类。
   可以看出，中介对象主要是用来封装行为的，行为的参与者就是那些对象，但是通过中介者，这些对象不用相互知道。呵呵~~~
   使用中介者模式的优点：
     1.降低了系统对象之间的耦合性，使得对象易于独立的被复用。
     2.提高系统的灵活性，使得系统易于扩展和维护。
   使用中介者模式的缺点：
   中介者模式的缺点是显而易见的，因为这个“中介“承担了较多的责任，所以一旦这个中介对象出现了问题，那么整个系统就会受到重大的影响。