20_中介者模式

中介者模式是一种行为型设计模式，它通过封装一系列对象之间的交互，使得对象之间的通信和协作更加松散和灵活。中介者模式将复杂的交互逻辑集中在中介者对象中，减少了对象之间的直接耦合。

中介者模式有四个主要角色：

1. 抽象中介者（Mediator）：定义了中介者对象的接口，用于协调并管理对象之间的交互。可以是抽象类或接口。

2. 具体中介者（Concrete Mediator）：继承或实现了抽象中介者，并实现了中介者对象的接口。具体中介者负责协调和管理对象之间的交互。

3. 同事类（Colleague）：定义了与其他同事类交互的接口，包含一个指向中介者对象的引用。同事类可以是具体类或接口。

4. 具体同事类（Concrete Colleague）：继承或实现了同事类，并实现了与其他同事类交互的接口。具体同事类通过中介者对象来进行交互。

中介者模式的工作原理如下：

1. 各个同事类通过持有中介者对象的引用来进行交互。

2. 当一个对象需要与其他对象进行交互时，它将请求发送给中介者对象。

3. 中介者对象收到请求后，根据具体的交互逻辑来协调和管理其他对象之间的交互。

中介者模式的优点包括：

1. 减少了对象之间的直接耦合，对象之间的通信通过中介者进行，使得对象更加独立和可复用。

2. 可以集中管理和控制对象之间的交互逻辑，使得交互逻辑更加清晰和易于维护。

3. 可以简化系统的设计和开发，降低系统的复杂性。

中介者模式适用于以下场景：

1. 当一组对象之间的交互逻辑复杂且互相关联时，可以使用中介者模式。

2. 当对象之间的交互关系呈现为网状结构时，可以使用中介者模式来简化交互逻辑。

3. 当对象之间的交互关系需要动态地进行调整和修改时，可以使用中介者模式。

总结而言，中介者模式通过封装对象之间的交互，使得对象之间的通信和协作更加松散和灵活。它集中管理和控制对象之间的交互逻辑，降低了对象之间的直接耦合，同时也使得系统的设计和开发更加简单和清晰。

 案例场景：三人打扑克牌

Colleague

 /// <summary>
    /// 玩家抽象类
    /// </summary>
    public abstract  class PlayerBase
    {
        public string Name { get; set; }
        public int Money { get; set; }

        public PlayerBase(string name,int money)
        {
            Name = name;
            Money = money;
        }

        /// <summary>
        /// 展示
        /// </summary>
        public void Display()
        {
            Console.WriteLine($"{Name}还有{Money}钱");
        }
        public abstract void Win(MediatorBase mediator, int money);
        public abstract void Lose(MediatorBase mediator, int money);
    }

 

Concrete Colleague

/// <summary>
    /// 玩家A
    /// </summary>
    public class PlayerA : PlayerBase
    {
        public PlayerA(string name, int money) : base(name, money)
        {
        }/// <summary>
        /// A玩家赢
        /// </summary>
        /// <param name="mediator"></param>
        /// <param name="money"></param>
        public override void Win(MediatorBase mediator, int money)
        {
            mediator.AWin(money);
        }
        /// <summary>
        /// A玩家输
        /// </summary>
        /// <param name="mediator"></param>
        /// <param name="money"></param>
        public override void Lose(MediatorBase mediator, int money)
        {
            mediator.ALose(money);
        }
    }

internal class PlayerB : PlayerBase
    {
        public PlayerB(string name, int money) : base(name, money)
        {
        }/// <summary>
        /// B玩家赢
        /// </summary>
        /// <param name="mediator"></param>
        /// <param name="money"></param>
        public override void Win(MediatorBase mediator, int money)
        {
            mediator.BWin(money);
        }

        /// <summary>
        /// B玩家输
        /// </summary>
        /// <param name="mediator"></param>
        /// <param name="money"></param>
        public override void Lose(MediatorBase mediator, int money)
        {
            mediator.BLose(money);
        }
    }

internal class PlayerC : PlayerBase
    {
        public PlayerC(string name, int money) : base(name, money)
        {
        }/// <summary>
        /// C玩家赢
        /// </summary>
        /// <param name="mediator"></param>
        /// <param name="money"></param>
        public override void Win(MediatorBase mediator, int money)
        {
            mediator.CWin(money);
        }

        /// <summary>
        /// C玩家输
        /// </summary>
        /// <param name="mediator"></param>
        /// <param name="money"></param>
        public override void Lose(MediatorBase mediator, int money)
        {
            mediator.CLose(money);
        }
    }

 

 Mediator

/// <summary>
    /// 中介者抽象类
    /// </summary>
    public abstract class MediatorBase
    {
        //定义三个玩家
        protected PlayerBase a;
        protected PlayerBase b;
        protected PlayerBase c;

        public MediatorBase(PlayerBase a, PlayerBase b, PlayerBase c)
        {
            this.a = a;
            this.b = b;
            this.c = c;
        }

        //6种状态
        //赢
        public abstract void AWin(int money);
        public abstract void BWin(int money);
        public abstract void CWin(int money);
        //输
        public abstract void ALose(int money);
        public abstract void BLose(int money);
        public abstract void CLose(int money);
    }

 

 Concrete Mediator

public class Mediator : MediatorBase
    {
        public Mediator(PlayerBase a, PlayerBase b, PlayerBase c) : base(a, b, c)
        {
        }

        public override void ALose(int money)
        {
            a.Money -= money * 2;
            b.Money += money;
            c.Money += money;
        }

        public override void AWin(int money)
        {
            a.Money += money * 2;
            b.Money -= money;
            c.Money -= money;
        }

        public override void BLose(int money)
        {
            b.Money -= money * 2;
            a.Money += money;
            c.Money += money;
        }

        public override void BWin(int money)
        {
            b.Money += money * 2;
            a.Money -= money;
            c.Money -= money;
        }

        public override void CLose(int money)
        {
            c.Money -= money * 2;
            a.Money += money;
            b.Money += money;
        }

        public override void CWin(int money)
        {
            c.Money += money * 2;
            a.Money -= money;
            b.Money -= money;
        }
    }

 

 调用

public class Client
    {
        public void Start()
        {
            Console.WriteLine("--------------中介者模式----------------------");

            PlayerBase a = new PlayerA("玩家A", 100);
            PlayerBase b = new PlayerB("玩家B", 100);
            PlayerBase c = new PlayerC("玩家C", 100);
            a.Display();
            b.Display();
            c.Display();
            MediatorBase mediator=new Mediator(a,b, c);
             Console.WriteLine("A玩家赢了25钱");
            a.Win(mediator, 25);
            a.Display();
            b.Display();
            c.Display();

            Console.WriteLine("B输了10钱");
            b.Lose(mediator, 10/2);
            a.Display();
            b.Display();
            c.Display();

        }
    }

static void Main(string[] args)
        {
            new Client().Start();
            Console.ReadKey();
            Console.WriteLine("Hello, World!");
        }