设计模式(18) 中介者模式

一个软件系统中往往包含了很多的类，这些类之间会存在互相的调用，随着系统的升级、功能的扩展，这些相互调用关系会变得非常复杂，，大量的相互连接使得这样一个类型系统不太可能在没有其他类支持的情况下独立完成工作，久而久之这些类将变得像一个不可分割的整体，内部有着错综复杂的关联。这会导致后期维护特别困难，对系统或模块的任何较大的变动都可能造成无法预知的问题。

中介者模式

中介者模式可以解决这种问题。它通过提供一个中介类，来处理不同类之间的通信，这样可以降低多个类之间的通信复杂度，使代码更易于维护。中介者模式属于行为型模式。通过应用Mediator模式，可以将类与类之间的多对多的关系转化成一对多的关系，从而降低了类之间的耦合。

GOF对中介者模式描述为： Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.. — Design Patterns : Elements of Reusable Object-Oriented Software

UML类图：

代码实现

public interface IMediator<T>
{
    void Operation();
    void Register(IColleague<T> provider, params IColleague<T>[] consumers);
}

public interface IColleague<T>
{
    T Data { get; set; }
    IMediator<T> Mediator { get; set; }
}

public abstract class ColleagueBase<T> : IColleague<T>
{
    public virtual T Data { get; set; }
    private IMediator<T> mediator;
    public virtual IMediator<T> Mediator
    {
        get
        {
            return mediator;
        }
        set
        {
            mediator = value;
        }
    }
}

public class Mediator<T> : IMediator<T>
{
    private IColleague<T> provider;
    private IList<IColleague<T>> consumers;
    public void Operation()
    {
        if (provider != null && consumers != null && consumers.Count > 0)
        {
            foreach (var item in consumers)
            {
                item.Data = provider.Data;
            }
        }
    }

    public void Register(IColleague<T> provider, params IColleague<T>[] consumers)
    {
        this.provider = provider;
        if (consumers != null && consumers.Length > 0)
        {
            this.consumers = new List<IColleague<T>>(consumers);
        }
    }
}

public class ConcreteColleagueA : ColleagueBase<int>
{
    public override int Data
    {
        get => base.Data;
        set
        {
            base.Data = value;
            base.Mediator.Operation();
        }
    }
}

public class ConcreteColleagueB : ColleagueBase<int>
{
}

public class ConcreteColleagueC : ColleagueBase<int>
{
}

调用端：

public class Test
{
    public static void Entry()
    {
        Mediator<int> mA2BC = new Mediator<int>();
        ConcreteColleagueA a = new ConcreteColleagueA();
        ConcreteColleagueB b = new ConcreteColleagueB();
        ConcreteColleagueC c = new ConcreteColleagueC();

        a.Mediator = b.Mediator = c.Mediator = mA2BC;
        mA2BC.Register(a, b, c);
        a.Data = 20;
        Console.WriteLine($"a:{a.Data},b:{b.Data}, c:{c.Data}"); //a:20,b:20,c:20

        mA2BC.Register(a, b);
        a.Data = 30;
        Console.WriteLine($"a:{a.Data},b:{b.Data}, c:{c.Data}"); //a:30,b:30,c:20
    }
}