行为型模式 - 中介者模式

admin管理员组

文章数量:1621906

 

没有中介者的情况下:

    class Program
    {
        static void Main(string[] args)
        {
            Player a = new PlayerA(50);
            Player b = new PlayerA(100);
            a.Win(30,b);
            Console.WriteLine(a.Money);
            Console.WriteLine(b.Money);
            Console.ReadKey();
        }
    }

    abstract class Player
    {
        public decimal Money { get; set; }

        public abstract void Win(decimal money, Player player);
    }

    class PlayerA : Player
    {
        public PlayerA(decimal money)
        {
            this.Money = money;
        }
        public override void Win(decimal money, Player player)
        {
            this.Money += money;
            player.Money -= money;
        }
    }

    class PlayerB : Player
    {
        public PlayerB(decimal money)
        {
            this.Money = money;
        }
        public override void Win(decimal money, Player player)
        {
            this.Money += money;
            player.Money -= money;
        }
    }

 

虽然使用了抽象类,降低了各个玩家之间的耦合度,但是一个玩家的状态发生变化,会影响其他所有玩家状态的变化.

 

中介者模式:

    class Program
    {
        static void Main(string[] args)
        {
            Player a = new PlayerA(50);
            Player b = new PlayerB(100);
            Mediator m = new ConcreteMediator(a, b);
            a.Win(20, m);
            Console.WriteLine(a.Money);//70
            Console.WriteLine(b.Money);//80
            b.Win(50, m);
            Console.WriteLine(a.Money);//20
            Console.WriteLine(b.Money);//130
            Console.ReadKey();
        }
    }

    /// <summary>
    /// 中介者抽象类
    /// </summary>
    abstract class Mediator
    {
        public Player A { get; set; }
        public Player B { get; set; }
        protected Mediator(Player a, Player b)
        {
            this.A = a;
            this.B = b;
        }
        public abstract void AWin(decimal money);
        public abstract void BWin(decimal money);
    }

    /// <summary>
    /// 具体中介者
    /// </summary>
    class ConcreteMediator : Mediator
    {
        public ConcreteMediator(Player a, Player b) : base(a, b)
        {
        }

        public override void AWin(decimal money)
        {
            A.Money += money;
            B.Money -= money;
        }

        public override void BWin(decimal money)
        {
            B.Money += money;
            A.Money -= money;
        }

    }


    /// <summary>
    /// 玩家抽象类
    /// </summary>
    abstract class Player
    {
        public decimal Money { get; set; }

        public abstract void Win(decimal money, Mediator mediator);
    }

    /// <summary>
    /// 玩家A
    /// </summary>
    class PlayerA : Player
    {
        public PlayerA(decimal money)
        {
            this.Money = money;
        }
        public override void Win(decimal money, Mediator mediator)
        {
            mediator.AWin(money);
        }
    }


    /// <summary>
    /// 玩家B
    /// </summary>
    class PlayerB : Player
    {
        public PlayerB(decimal money)
        {
            this.Money = money;
        }
        public override void Win(decimal money, Mediator mediator)
        {
            mediator.BWin(money);
        }
    }

 

这种方式也有缺点,如果还要加入新的玩家,就不得不修改 Mediator 类, 增加 Player C ,和 CWin() 方法,这显然违背了开闭原则.

 

结合观察者模式

 

    class Program
    {
        static void Main(string[] args)
        {
            Player a = new PlayerA(50);
            Player b = new PlayerB(100);
            Mediator m = new ConcreteMediator();
            m.AddPlayer(a);
            m.AddPlayer(b);
            a.Win(20, m);
            Console.WriteLine(a.Money);//70
            Console.WriteLine(b.Money);//80

            //c 加入进来
            Player c = new PlayerC(200);
            m.AddPlayer(c);

            b.Win(140, m);
            Console.WriteLine(a.Money);//0
            Console.WriteLine(b.Money);//220
            Console.WriteLine(c.Money);//130
            
            //a 输完了,走了,b,c继续玩
            m.RemovePlayer(a);

            c.Win(220,m);
            Console.WriteLine(b.Money);//0
            Console.WriteLine(c.Money);//350

            Console.ReadKey();
        }
    }

    /// <summary>
    /// 中介者抽象类
    /// </summary>
    abstract class Mediator
    {
        public List<Player> PlayerList = new List<Player>();

        public void AddPlayer(Player player)
        {
            this.PlayerList.Add(player);
        }

        public void RemovePlayer(Player player)
        {
            this.PlayerList.Remove(player);
        }

        public abstract void Win(decimal money, Player player);
    }

    /// <summary>
    /// 具体中介者
    /// </summary>
    class ConcreteMediator : Mediator
    {

        public override void Win(decimal money, Player player)
        {
            int count = PlayerList.Count;

            foreach (var item in PlayerList)
            {
                if (item.Equals(player)) item.Money += money;
                else item.Money -= money / (count - 1);
            }
        }
    }


    /// <summary>
    /// 玩家抽象类
    /// </summary>
    abstract class Player
    {
        public decimal Money { get; set; }

        public abstract void Win(decimal money, Mediator mediator);
    }

    /// <summary>
    /// 玩家A
    /// </summary>
    class PlayerA : Player
    {
        public PlayerA(decimal money)
        {
            this.Money = money;
        }
        public override void Win(decimal money, Mediator mediator)
        {
            mediator.Win(money, this);
        }
    }


    /// <summary>
    /// 玩家B
    /// </summary>
    class PlayerB : Player
    {
        public PlayerB(decimal money)
        {
            this.Money = money;
        }
        public override void Win(decimal money, Mediator mediator)
        {
            mediator.Win(money, this);
        }
    }


    /// <summary>
    /// 玩家C
    /// </summary>
    class PlayerC : Player
    {
        public PlayerC(decimal money)
        {
            this.Money = money;
        }
        public override void Win(decimal money, Mediator mediator)
        {
            mediator.Win(money, this);
        }
    }

 

转载于:https://wwwblogs/refuge/p/8544345.html

本文标签： 模式中介