模式定义
中介者模式(Mediator Pattern)定义：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显示地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
UML类图
- 抽象中介者 Mediator 定义一个接口，该接口用于与各同事对象之间的通信方法
Send(stirng msg) - 具体中介者 ConcreteMediator 抽象中介者的子类，依赖同事类，实现抽象中介者接口（）。
- 抽象同事类 Colleague 关联抽象中介对象，定义各同事的抽象方法（包发送同事方法
Send(string msg)和接受同事方法Notify(string msg)）。 - 具体同事类 ConcreteColleague 同事类的子类，实现同事间发送消息和接受消息
代码结构
public static class MediatorApp
{
public static void Run()
{
ConcreteMediator m = new ConcreteMediator();
ConcreteColleague1 c1 = new ConcreteColleague1(m);
ConcreteColleague2 c2 = new ConcreteColleague2(m);
m.Colleague1 = c1;
m.Colleague2 = c2;
c1.Send("How are you?");
c2.Send("Fine,thanks");
Console.ReadKey();
}
}
/// <summary>
/// 抽象中介者
/// </summary>
abstract class Mediator
{
public abstract void Send(string message, Colleague colleague);
}
/// <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>
/// 抽象同事类，关联抽象中介者，两个“同事”的通信通过中介者
/// </summary>
abstract class Colleague
{
protected Mediator mediator;
public Colleague(Mediator mediator)
{
this.mediator = mediator;
}
}
/// <summary>
/// 具体中介者
/// </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("Colleague1 gets message:"+message);
}
}
/// <summary>
/// 具体中介者
/// </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("Colleague2 gets message:" + message);
}
}
情景案例
这里实现个简单的小游戏，游戏的参与者有Cumputer和Person两个角色，参与者可以攻击不同角色，受到攻击，死亡后通知所有参与者，接受通知。
public static class RealWorldMediatorApp
{
public static void Run()
{
Game game = new Game();
Computer com1 = new Computer(game, "Computer1");
Computer com2 = new Computer(game, "Computer2");
Person per1 = new Person(game, "Person1");
Person per2 = new Person(game, "Person2");
game.Register(com1);
game.Register(com2);
game.Register(per1);
game.Register(per2);
for (int i = 0; i < 10; i++)
{
com1.Attack("Person1");
per2.Attack("Computer2");
com2.Attack("Person2");
per1.Attack("Computer1");
}
Console.ReadKey();
}
}
/// <summary>
/// 抽象中介者
/// </summary>
abstract class AbstractGame
{
public abstract void Register(Member member);
public abstract void Attack(Member attacker, string attackee);
public abstract void Notify(Member member);
}
/// <summary>
/// 具体中介者（管理相互交换的两个‘同事’类）
/// </summary>
class Game : AbstractGame
{
private Dictionary<string, Member> _computerLst = new Dictionary<string, Member>();
private Dictionary<string, Member> _personLst = new Dictionary<string, Member>();
public override void Attack(Member attacker, string attackee)
{
Member attackeeMember;
if (attacker.GetType() == typeof(Computer))
{
attackeeMember = _personLst[attackee];
}
else
{
attackeeMember = _computerLst[attackee];
}
attackeeMember.Hurt();
}
public override void Notify(Member member)
{
foreach (var item in _personLst)
{
if (item.Value.IsLive)
{
string msg = member.Name + " is dead";
item.Value.ReceiveNotify(msg);
}
}
foreach (var item in _computerLst)
{
if (item.Value.IsLive)
{
string msg = member.Name + " is dead";
item.Value.ReceiveNotify(msg);
}
}
}
public override void Register(Member member)
{
if (member.GetType() == typeof(Computer))
{
_computerLst.Add(member.Name, member);
}
else
{
_personLst.Add(member.Name, member);
}
}
}
/// <summary>
/// 抽象同事类，关联抽象中介者，两个“同事”的通信通过中介者
/// </summary>
abstract class Member
{
public bool IsLive { get; private set; }
private string _name = string.Empty;
public string Name
{
get
{
return _name;
}
}
protected AbstractGame mediator;
public Member(AbstractGame mediator, string name)
{
this.mediator = mediator;
this._name = name;
this.IsLive = true;
}
public void Attack(string attackee)
{
if (this.IsLive)
{
mediator.Attack(this, attackee);
}
}
public void Hurt()
{
Random rd = new Random();
int ranNum = rd.Next(0, 2);
if (this.IsLive && ranNum == 1)
{
this.IsLive = false;
mediator.Notify(this);
}
}
public void ReceiveNotify(string msg)
{
string strMsg = this.Name + " Receive :" + msg;
Console.WriteLine(strMsg);
}
}
/// <summary>
/// 电脑角色
/// </summary>
class Computer : Member
{
public Computer(AbstractGame mediator, string name) : base(mediator, name)
{
}
}
/// <summary>
/// 人员角色
/// </summary>
class Person : Member
{
public Person(AbstractGame mediator, string name) : base(mediator, name)
{
}
}