DesignPattrn-中介者模式

admin管理员组

文章数量:1621899

中介者模式相当于中间平台，一切操作都有中间平台去分发，中介者模式，兴义了一个中介对象来封装一些列对象之间的交互关系。中介者是各个对昂之间不需要显示地相互引用，从而使耦合性降低，而且可以独立改变他们之间的交互行为。

对应现实生活中，中介者模式，打牌总有输赢，对应的每个参与者货币的变化：

/// <summary>
/// 抽象牌友类
/// </summary>
public abstract class AbstractCardPartner
{
    public int Money { get; set; }
 
    public abstract void ChangeMoney(int money, AbstractCardPartner other);
}
 
/// <summary>
/// 牌友A
/// </summary>
public class PartnerA : AbstractCardPartner
{
    public override void ChangeMoney(int money, AbstractCardPartner other)
    {
        Money += money;
        other.Money -= money;
    }
}
 
/// <summary>
/// 牌友B
/// </summary>
public class PartnerB : AbstractCardPartner
{
    public override void ChangeMoney(int money, AbstractCardPartner other)
    {
        Money += money;
        other.Money -= money;
    }
}
 
/// <summary>
/// 调用
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
    AbstractCardPartner A = new PartnerA();
    A.Money = 20;
    AbstractCardPartner B = new PartnerB();
    B.Money = 20;
 
    // A赢了B的钱减少
    A.ChangeMoney(5, B);
    Console.WriteLine("A 现在的钱是：{0}", A.Money); // 应该是25
    Console.WriteLine("B 现在的钱是：{0}", B.Money); // 应该是15
 
    // B赢了A的钱减少
    B.ChangeMoney(10, A);
    Console.WriteLine("A 现在的钱是：{0}", A.Money); // 应该是15
    Console.WriteLine("B 现在的钱是：{0}", B.Money); // 应该是25
 
    Console.ReadLine();
}

确实解决了问题，但是如果其中牌友A发生变化，此时会影响到牌友B，如果涉及的对象变多，这时候一个牌友的变换将会影响其他素有相关联的牌友状态。牌友A算错了前，这时候，牌友A和牌友B的钱都不正确了，多个人打牌，影响的对象就会更多，这时候----把算钱的任务交给程序or算数好的人去计算，就有了类似平台计算的东西。

我们引入中介者，来协调各个对象之间的关联，

public abstract class AbstractCardPartner
{
    public int Money { get; set; }
 
    public abstract void ChangeMoney(int money, AbstractMediator mediator);
}
 
/// <summary>
/// 牌友A
/// </summary>
public class PartnerA : AbstractCardPartner
{
    public override void ChangeMoney(int money, AbstractMediator mediator)
    {
        mediator.AWin(money);
    }
}
 
/// <summary>
/// 牌友B
/// </summary>
public class PartnerB : AbstractCardPartner
{
    public override void ChangeMoney(int money, AbstractMediator mediator)
    {
        mediator.BWin(money);
    }
}
 
/// <summary>
/// 抽象中介者类
/// </summary>
public abstract class AbstractMediator
{
    protected AbstractCardPartner A;
    protected AbstractCardPartner B;
 
    public AbstractMediator(AbstractCardPartner a, AbstractCardPartner b)
    {
        A = a;
        B = b;
    }
 
    public abstract void AWin(int money);
    public abstract void BWin(int money);
}
 
/// <summary>
/// 调用
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
    AbstractCardPartner A = new PartnerA();
    AbstractCardPartner B = new PartnerB();
    A.Money = 20;
    B.Money = 20;
 
    AbstractMediator mediator = new MediatorPater(A, B);
 
    // A赢了
    A.ChangeMoney(5, mediator);
    Console.WriteLine("A 现在的钱是：{0}", A.Money); // 应该是25
    Console.WriteLine("B 现在的钱是：{0}", B.Money); // 应该是15
 
    // B赢了
    B.ChangeMoney(10, mediator);
    Console.WriteLine("A 现在的钱是：{0}", A.Money); // 应该是15
    Console.WriteLine("B 现在的钱是：{0}", B.Money); // 应该是25
 
    Console.ReadLine();
}

中介者类保存两个抽象牌友类，如果新添加的一个牌友，此时就需要更改这个抽象中介者类，结合观察者模式可以解决这个问题，但避免不了的是添加CWin方法

优点：
简化了对象之间的关系，将系统的各个对象之间的相互关系进行封装，将各个同事类进行解耦，使得系统编的耦合

提供系统的灵活性，使得各个同时对象独立而易于复用

缺点：
中介者模式中，中介者角色承担了较多的责任，所以一旦这个中介者对象出了问题，整个系统会受到重大的影响。

新增加一个同事类，不得不去修改抽象中介者类，（即便使用观察者模式）

适用场景：
一组定义良好的对象，现在要进行复杂的相互通信。
想通过一个中间类来封装多个类的行为，又不想生成太多子类。

本文标签： 中介模式DesignPattrn