一、定义
又称为调停者模式，定义一个中介对象来封装系列对象之间的交互。中介者使各个对象不需要显示地相互引用，从而使其耦合性松散，而且可以独立地改变他们之间的交互。
二、结构
组成：
● 抽象中介者(Mediator)角色：定义统一的接口用于各同事角色之间的通信，其中主要方法是一个（或多个）事件方法。
● 具体中介者(ConcreteMediator)角色：实现了抽象中介者所声明的事件方法。具体中介者知晓所有的具体同事类，并负责具体的协调各同事对象的交互关系。
● 抽象同事类(Colleague)角色：定义出中介者到同事角色的接口。同事角色只知道中介者而不知道其余的同事角色。与其他的同事角色通信的时候，一定要通过中介者角色协作。
● 具体同事类(ConcreteColleague)角色：所有的具体同事类均从抽象同事类继承而来。实现自己的业务，在需要与其他同事通信的时候，就与持有的中介者通信，中介者会负责与其他的同事交互。
代码结构
//抽象中介者类
public interface IMediator
{
/**
* 同事对象在自身改变的时候来通知中介者的方法
* 让中介者去负责相应的与其他同事对象的交互
*/
void Changed(Colleague c);
} //抽象同事类
public abstract class Colleague
{
//持有一个中介者对象
private IMediator _mediator;
/**
* 构造函数
*/
public Colleague(IMediator mediator)
{
this._mediator = mediator;
}
/**
* 获取当前同事类对应的中介者对象
*/
public IMediator GetMediator()
{
return _mediator;
}
} //具体中介者类
public class ConcreteMediator : IMediator
{
//持有并维护同事A
private ConcreteColleagueA _colleagueA;
//持有并维护同事B
private ConcreteColleagueB _colleagueB; public void SetColleagueA(ConcreteColleagueA colleagueA)
{
this._colleagueA = colleagueA;
} public void SetColleagueB(ConcreteColleagueB colleagueB)
{
this._colleagueB = colleagueB;
} public void Changed(Colleague c)
{
/**
* 某一个同事类发生了变化，通常需要与其他同事交互
* 具体协调相应的同事对象来实现协作行为
*/
}
} //具体同事类
public class ConcreteColleagueA : Colleague
{ public ConcreteColleagueA(IMediator mediator) : base(mediator)
{
}
/**
* 示意方法，执行某些操作
*/
public void Operation()
{
//在需要跟其他同事通信的时候，通知中介者对象
GetMediator().Changed(this);
}
}
public class ConcreteColleagueB : Colleague
{ public ConcreteColleagueB(IMediator mediator) : base(mediator)
{
}
/**
* 示意方法，执行某些操作
*/
public void Operation()
{
//在需要跟其他同事通信的时候，通知中介者对象
GetMediator().Changed(this);
}
}
三、适用场景
1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。
2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。
应用实例
1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。
2、机场调度系统。
3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。
四、优缺点
优点： 1、降低了类的复杂度，将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。
缺点：中介者会庞大，变得复杂难以维护。
五、实现
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace DesignPatterns.Mediator
{
class Program
{
static void Main(string[] args)
{
MessageMediator mediator = new MessageMediator(); ConcreteColleagueA a = new ConcreteColleagueA(mediator, "A");
ConcreteColleagueB b = new ConcreteColleagueB(mediator, "B");
ConcreteColleagueC c = new ConcreteColleagueC(mediator, "C"); mediator.SetColleagueA(a);
mediator.SetColleagueB(b);
mediator.SetColleagueC(c); mediator.Chat(a, "中午吃啥饭？");
Console.WriteLine("===="); mediator.Chat(b, "我想吃刀削面");
Console.WriteLine("===="); mediator.Chat(c, "我也想吃刀削面");
Console.WriteLine("===="); mediator.Chat(a, "行，那中午一起去吃刀削面吧");
}
} //抽象中介者类
public interface IMediator
{
void Chat(Colleague c, string message);
} //抽象同事类
public abstract class Colleague
{
private string name;
//持有一个中介者对象
private IMediator _mediator; public Colleague(IMediator mediator, string name)
{
this._mediator = mediator;
this.name = name;
}
/**
* 获取当前同事类对应的中介者对象
*/
public IMediator GetMediator()
{
return _mediator;
} /**
* 获取昵称
*/
public string getName()
{
return name;
} /**
* 接收消息
*/
public abstract void receive(string message); /**
* 发送消息
*/
public abstract void send(string message);
} //具体中介者类
public class MessageMediator : IMediator
{
//持有并维护同事A
private ConcreteColleagueA _colleagueA;
//持有并维护同事B
private ConcreteColleagueB _colleagueB; private ConcreteColleagueC _colleagueC; public void SetColleagueA(ConcreteColleagueA colleagueA)
{
this._colleagueA = colleagueA;
} public void SetColleagueB(ConcreteColleagueB colleagueB)
{
this._colleagueB = colleagueB;
}
public void SetColleagueC(ConcreteColleagueC colleagueC)
{
this._colleagueC = colleagueC;
} public void Chat(Colleague c, string message)
{
if (_colleagueA != null)
{
_colleagueA.send(message);
_colleagueB.receive(message);
_colleagueC.receive(message);
}
else if (_colleagueB != null) {
_colleagueB.send(message);
_colleagueA.receive(message);
_colleagueC.receive(message);
} else if (_colleagueC != null) {
_colleagueC.send(message);
_colleagueA.receive(message);
_colleagueB.receive(message);
}
}
} //具体同事类
public class ConcreteColleagueA : Colleague
{ public ConcreteColleagueA(IMediator mediator, string name) : base(mediator, name)
{
}
/**
* 示意方法，执行某些操作
*/
public void Operation(string message)
{
//在需要跟其他同事通信的时候，通知中介者对象
GetMediator().Chat(this, message);
} public override void receive(String message)
{
Console.WriteLine("【A】收到消息：【" + message + "】");
} public override void send(String message)
{
Console.WriteLine("【A】发出消息：【" + message + "】");
}
}
public class ConcreteColleagueB : Colleague
{ public ConcreteColleagueB(IMediator mediator, string name) : base(mediator, name)
{
}
/**
* 示意方法，执行某些操作
*/
public void Operation(string message)
{
//在需要跟其他同事通信的时候，通知中介者对象
GetMediator().Chat(this, message);
} public override void receive(String message)
{
Console.WriteLine("【B】收到消息：【" + message + "】");
} public override void send(String message)
{
Console.WriteLine("【B】发出消息：【" + message + "】");
}
} public class ConcreteColleagueC : Colleague
{ public ConcreteColleagueC(IMediator mediator, string name) : base(mediator, name)
{
}
/**
* 示意方法，执行某些操作
*/
public void Operation(string message)
{
//在需要跟其他同事通信的时候，通知中介者对象
GetMediator().Chat(this, message);
} public override void receive(String message)
{
Console.WriteLine("【C】收到消息：【" + message + "】");
} public override void send(String message)
{
Console.WriteLine("【C】发出消息：【" + message + "】");
}
}
}
结果
【A】发出消息：【中午吃啥饭？】
【B】收到消息：【中午吃啥饭？】
【C】收到消息：【中午吃啥饭？】
====
【A】发出消息：【我想吃刀削面】
【B】收到消息：【我想吃刀削面】
【C】收到消息：【我想吃刀削面】
====
【A】发出消息：【我也想吃刀削面】
【B】收到消息：【我也想吃刀削面】
【C】收到消息：【我也想吃刀削面】
====
【A】发出消息：【行，那中午一起去吃刀削面吧】
【B】收到消息：【行，那中午一起去吃刀削面吧】
【C】收到消息：【行，那中午一起去吃刀削面吧】
参考：
http://www.cnblogs.com/JsonShare/p/7263876.html
http://www.runoob.com/design-pattern/mediator-pattern.html