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

本文主要是介绍设计模式深入学习--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.提高系统的灵活性，使得系统易于扩展和维护。
使用中介者模式的缺点：
中介者模式的缺点是显而易见的，因为这个“中介“承担了较多的责任，所以一旦这个中介对象出现了问题，那么整个系统就会受到重大的影响。

这篇关于设计模式深入学习--Mediator 中介者模式(行为型模式)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！