設計模式(20)---中介者模式設計模式之中介者模式（Mediator）

時間 2019-12-05

原文原文鏈接

1、定義html

中介者模式：用一箇中介對象來封裝一系列的對象交互。中介者使對象不須要顯式地相互引用，從而使其耦合鬆散，並且能夠獨立地改變它們之間的交互。設計模式

解釋：通俗來說，有多個對象，它們相互之間有交互。如今爲了下降它們的耦合度，提供一箇中介者，至關於第三方，各個對象都經過第三方來進行相互間的邏輯操做。ide

2、UML類圖及基本代碼post

基本代碼：this

abstract class Mediator
    {
        public abstract void Send(string message, Colleague colleague);
    }

    class ConcreteMediator : Mediator
    {
        private ConcreteColleage1 colleague1;
        private ConcreteColleage2 colleague2;

        public ConcreteColleage1 Colleague1
        {
            set { colleague1 = value; }
        }

        public ConcreteColleage2 Colleague2
        {
            set { colleague2 = value; }
        }

        public override void Send(string message, Colleague colleague)
        {
            if (colleague == colleague1)
            {
                colleague2.Receive(message);
            }
            else
            {
                colleague1.Receive(message);
            }
        }
    }

    abstract class Colleague
    {
        protected Mediator mediator;

        public Colleague(Mediator mediator)
        {
            this.mediator = mediator;
        }
    }

    class ConcreteColleage1 : Colleague
    {
        public ConcreteColleage1(Mediator mediator)
            : base(mediator)
        { }

        public void Send(string message)
        {
            mediator.Send(message, this);
        }

        public void Receive(string message)
        {
            Console.WriteLine("同事1獲得信息：" + message);
        }
    }

    class ConcreteColleage2 : Colleague
    {
        public ConcreteColleage2(Mediator mediator)
            : base(mediator)
        { }

        public void Send(string message)
        {
            mediator.Send(message, this);
        }

        public void Receive(string message)
        {
            Console.WriteLine("同事2獲得信息：" + message);
        }
    }

客戶端調用及其結果：url

ConcreteMediator mediator = new ConcreteMediator();
            ConcreteColleage1 c1 = new ConcreteColleage1(mediator);
            ConcreteColleage2 c2 = new ConcreteColleage2(mediator);

            mediator.Colleague1 = c1;
            mediator.Colleague2 = c2;

            c1.Send("吃飯了嗎？");
            c2.Send("尚未，你打算請客？");

3、具體實例spa

A和B博弈，A贏則B會輸，反之亦然。假設A和B開始時都要20塊錢，基本代碼以下：設計

首先構造抽象中介者類和具體中介者類：code

public abstract class AbstractMediator
    {
        public abstract void AWin(int count);
        public abstract void BWin(int count);
    }

    public class MediatorPater : AbstractMediator
    {
        private ParterA a;
        private ParterB b;

        public ParterA A
        {
            set { a = value; }
        }

        public ParterB B
        {
            set { b = value; }
        }

        public override void AWin(int count)
        {
            a.MoneyCount += count;
            b.MoneyCount -= count;
        }

        public override void BWin(int count)
        {
            b.MoneyCount += count;
            a.MoneyCount -= count;
        }
    }

接着編寫抽象對弈者，構造具體的對弈者A和B：htm

public abstract class AbstractCardPartner
    {
        public int MoneyCount { get; set; }
        public AbstractCardPartner()
        {
            MoneyCount = 0;
        }

        public abstract void ChangeCount(int count, AbstractMediator mediator);
    }

    public class ParterA : AbstractCardPartner
    {
        public override void ChangeCount(int Count, AbstractMediator mediator)
        {
            mediator.AWin(Count);
        }
    }

    public class ParterB : AbstractCardPartner
    {
        public override void ChangeCount(int Count, AbstractMediator mediator)
        {
            mediator.BWin(Count);
        }
    }

客戶端調用代碼及其結果：

MediatorPater mediator = new MediatorPater();
            ParterA partA = new ParterA();
            ParterB partB = new ParterB();

            mediator.A = partA;
            mediator.B = partB;

            partA.MoneyCount = 20;
            partB.MoneyCount = 20;

            partA.ChangeCount(7, mediator);
            Console.WriteLine("A 如今的錢是：{0}", partA.MoneyCount);
            Console.WriteLine("B 如今的錢是：{0}", partB.MoneyCount); 

            partB.ChangeCount(11, mediator);
            Console.WriteLine("A 如今的錢是：{0}", partA.MoneyCount);
            Console.WriteLine("B 如今的錢是：{0}", partB.MoneyCount);

4、優缺點及其適用場景

優勢：

1）將各個對象類解耦，同時簡化對象之間的關係，使系統變爲鬆耦合。

2）系統更加靈活，各個對象獨立而易於複用。

缺點：

1）中介者模式中，中介者承擔了較大的責任，一旦中介者出現問題，整個系統都會受到較大的影響。

2）新增一個對象類，須要修改抽象中介者和具體中介者類。

適用場景：

中介者模式通常應用於一組對象以定義良好可是複雜的方式進行通訊的場合，及想定製一個分佈在多個類中的行爲，而又不想生成太多的子類的場合。

補充：

再次重溫中介者模式，發現該模式好像有些雞肋，發現上面展現的中介者的基本代碼的耦合度過高了，因而網上搜索其它關於中介者的實例，但願能從那些實例中獲得一些啓發。而事實是確實找到一個比較好的實例，實例以下：

抽象對象：

abstract class Colleague
    {
        private string name;
        private string content;

        public Colleague(string name)
        {
            this.name = name;
        }

        public void SetContent(string content)
        {
            this.content = content;
        }

        public string GetContent()
        {
            return this.content;
        }

        public abstract void Talk();
    }

添加幾個具體的對象：

class ConcreteColleagueMonitor : Colleague
    {
        public ConcreteColleagueMonitor (string name):base(name){}

        public override void Talk()
        {
            Console.WriteLine("班長說：" + GetContent());
        }
    }

    class ConcreteColleague1 : Colleague
    {
        public ConcreteColleague1(string name) : base(name) { }

        public override void Talk()
        {
            Console.WriteLine("同窗1說：" + GetContent());
        }
    }

    class ConcreteColleague2 : Colleague
    {
        public ConcreteColleague2 (string name):base(name){}

        public override void Talk()
        {
            Console.WriteLine("同窗2說：" + GetContent());
        }
    }

View Code

抽象中介者：

abstract class Mediator
    {
        public IList<Colleague> Colleagues = new List<Colleague>();

        public abstract void Notify(Colleague colleague);
        public abstract void Chart(Colleague colleague1, Colleague colleague2);

        public void AddColleague(Colleague colleague)
        {
            Colleagues.Add(colleague);
        }
    }

具體的中介者qq羣：

class QQMediator : Mediator
    {
        public override void Notify(Colleague colleague)
        {
            colleague.Talk();

            foreach (Colleague c in Colleagues)
            {
                if (c != colleague) c.Talk();
            }
        }

        public override void Chart(Colleague colleague1, Colleague colleague2)
        {
            colleague1.Talk();
            colleague2.Talk();
        }
    }

客戶端調用代碼：

QQMediator qq = new QQMediator();

            ConcreteColleagueMonitor monitor = new ConcreteColleagueMonitor("班長");
            ConcreteColleague1 colleague1 = new ConcreteColleague1("同窗1");
            ConcreteColleague2 colleague2 = new ConcreteColleague2("同窗2");

            Console.WriteLine("班長髮通知場景：");
            qq.AddColleague(monitor);
            qq.AddColleague(colleague1);
            qq.AddColleague(colleague2);
            monitor.SetContent("今天中午聚餐,收到回覆");
            colleague1.SetContent("沒問題");
            colleague2.SetContent("能夠，可是會晚到");
            qq.Notify(monitor);
            Console.WriteLine(".......................................................");

            Console.WriteLine("兩個同窗(班長、同窗2)私下交流：");
            monitor.SetContent("明天一塊去逛街，怎麼樣?");
            colleague2.SetContent("能夠呀，早就想去了。");
            qq.Chart(monitor, colleague2);