模式简介

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

通常情况下，应用程序由许多类组成，随着类数量不断增加，系统变得难以维护，主要体现在类之间的交互变得更加复杂，难以理解，修改其中一个类可能会影响到其他的类，导致整个系统崩溃。

想象机场控制塔控制飞机起飞降落的过程，飞机降落前先与机场控制塔通信，控制塔通知其它飞机暂时不要降落，跑道已经被占用了。这是一个典型的中介者模式，飞机间的通信统一通过机场控制塔，而不是各自进行通信，当某架飞机希望降落时，只需要通过控制塔，不用直接通知其它等待降落的飞机。

结构分析

UML类图

角色说明

• Mediator

抽象中介者。定义一个接口，用于同事类之间的通信。

• ConcreteMediator

具体中介者，了解并维护各个同事，协调同事对象实现协作。

• Colleague

抽象同事类

• ConcreteColleague

具体同事类，通过中介者与其它同事进行通信。

工作原理

同事向中介者对象发送和接受请求，中介者在各同事间适当地转发请求以实现协作行为。

结构代码

//抽象中介者
public interface IMediator
{
    void SendMessage(string message, Colleague colleague);
}

//具体中介者
public class ConcreteMediator : IMediator
{
    public ConcreteColleagueA ConcreteColleagueA { get; set; }
    public ConcreteColleagueB ConcreteColleagueB { get; set; }
    public void SendMessage(string message, Colleague colleague)
    {
        if (colleague == ConcreteColleagueA)
        {
            ConcreteColleagueB.Receive(message);
        }
        else
        {
            ConcreteColleagueA.Receive(message);
        }
    }
}

//抽象同事类
public abstract class Colleague
{
    protected IMediator _mediator;
    public Colleague(IMediator mediator)
    {
        this._mediator = mediator;
    }

    public abstract void Send(string message);
    public abstract void Receive(string message);
}

//具体同事类A
public class ConcreteColleagueA : Colleague
{
    public ConcreteColleagueA(IMediator mediator) : base(mediator)
    {
    }

    public override void Receive(string message)
    {
        Console.WriteLine($"ConcreteColleagueA Receive Message:{message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"ConcreteColleagueA Send Message:{message}");
        _mediator.SendMessage(message, this);
    }
}

//具体同事类B
public class ConcreteColleagueB : Colleague
{
    public ConcreteColleagueB(IMediator mediator) : base(mediator)
    {
    }

    public override void Receive(string message)
    {
        Console.WriteLine($"ConcreteColleagueB Receive Message:{message}");
    }

    public override void Send(string message)
    {
        Console.WriteLine($"ConcreteColleagueB Send Message:{message}");
        _mediator.SendMessage(message, this);
    }
}

客户端调用

static void Main(string[] args)
{
    ConcreteMediator mediator = new ConcreteMediator();
    ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
    ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);

    mediator.ConcreteColleagueA = colleagueA;
    mediator.ConcreteColleagueB = colleagueB;

    colleagueA.Send("Hello,how are you?");
    colleagueB.Send("Fine,thank you.And you?");
    Console.ReadLine();
}

输出结果：

示例分析

本节讲述飞机之间通过控制塔进行通信的示例。首先创建控制塔类ControlTower，这里省略了抽象中介者。

public class ControlTower
{
    private Dictionary<string, AbstractPlane> _planes = new Dictionary<string, AbstractPlane>();

    public void Register(AbstractPlane plane)
    {
        if (!_planes.ContainsValue(plane))
        {
            _planes[plane.Name] = plane;
        }

        plane.ControlTower = this;
    }

    public void SendMessage(string from, string to, string message)
    {
        if (_planes.ContainsKey(to))
        {
            _planes[to].Receive(from, message);
        }
    }
}

声明抽象同事类AbstractPlane，并实现具体同时类AirLiner。

public abstract class AbstractPlane
{
    protected string _name;
    public AbstractPlane(string name)
    {
        _name = name;   
    }

    public ControlTower ControlTower { get; set; }
    public string Name
    {
        get { return _name; }
    }
    public abstract void Send(string to, string message);
    public abstract void Receive(string from, string message);
}

public class Airliner : AbstractPlane
{
    public Airliner(string name) : base(name)
    {
    }

    public override void Receive(string from, string message)
    {
        Console.WriteLine($"{this.Name} Receive Message:{message} from {from}");
    }

    public override void Send(string to, string message)
    {
        ControlTower.SendMessage(this.Name, to, message);
    }
}

客户端调用，向控制塔对象注册5架飞机，airLinerA通过控制塔对象与airLinerB进行通讯。

class Program
{
    static void Main(string[] args)
    {
        ControlTower tower = new ControlTower();
        Airliner airLinerA = new Airliner("A");
        Airliner airLinerB = new Airliner("B");
        Airliner airLinerC = new Airliner("C");
        Airliner airLinerD = new Airliner("D");
        Airliner airLinerE = new Airliner("E");

        tower.Register(airLinerA);
        tower.Register(airLinerB);
        tower.Register(airLinerC);
        tower.Register(airLinerD);
        tower.Register(airLinerE);

        airLinerA.Send("B","When will you arrive?");
        airLinerB.Send("A", "Already landed.");
        Console.ReadLine();
    }
}

使用场景

• 一组对象以定义良好但是复杂的方式进行通信。产生的相互依赖关系结构混乱且难以理解。

• 一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象。

• 想定制一个分布在多个类中的行为，而又不想生成太多的子类。