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!");
        }

 

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章