中介者模式

中介者模式结构：

 

 

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesignPattern.BehavioralPattern
{
    #region 中介者模式模式
    //定义：　中介者模式，定义了一个中介对象来封装一系列对象之间的交互关系。
    //
    //核心思想：
    //中介者模式建议你停止组件之间的直接交流并使其相互独立。
    //这些组件必须调用特殊的中介者对象， 通过中介者对象重定向调用行为， 以间接的方式进行合作。
    //最终，组件仅依赖于一个中介者类， 无需与多个其他组件相耦合。
    //
    //使用场景：
    //1.当一些对象和其他对象紧密耦合以致难以对其进行修改时
    //2.当组件因过于依赖其他组件而无法在不同应用中复用时
    //3.如果为了能在不同情景下复用一些基本行为， 导致你需要被迫创建大量组件子类时，
    //
    //
    /*
     * 实现方式：
       1.找到一组当前紧密耦合， 且提供其独立性能带来更大好处的类 （例如更易于维护或更方便复用）。
       
       2.声明中介者接口并描述中介者和各种组件之间所需的交流接口。 
         在绝大多数情况下， 一个接收组件通知的方法就足够了。 
         如果你希望在不同情景下复用组件类， 那么该接口将非常重要。 
         只要组件使用通用接口与其中介者合作， 你就能将该组件与不同实现中的中介者进行连接。
       
       3.实现具体中介者类。 该类可从自行保存其下所有组件的引用中受益。
       
       4.你可以更进一步， 让中介者负责组件对象的创建和销毁。 
         此后， 中介者可能会与工厂或外观类似。
       
       5.组件必须保存对于中介者对象的引用。 
         该连接通常在组件的构造函数中建立， 该函数会将中介者对象作为参数传递。
       
       6.修改组件代码， 使其可调用中介者的通知方法， 而非其他组件的方法。 
         然后将调用其他组件的代码抽取到中介者类中， 并在中介者接收到该组件通知时执行这些代码。
     */
    #endregion

    //中介者 （Mediator） 接口声明了与组件交流的方法， 但通常仅包括一个通知方法。
    //组件可将任意上下文 （包括自己的对象） 作为该方法的参数， 只有这样接收组件和发送者类之间才不会耦合。
    public interface IMediatorPattern
    {
        void Notify(BaseConponent sender, string param);
    }

    //具体中介者 （Concrete Mediator） 封装了多种组件间的关系。
    //具体中介者通常会保存所有组件的引用并对其进行管理， 甚至有时会对其生命周期进行管理。
    public class ConcreteMediator : IMediatorPattern
    {
        ConponentA _conponentA;
        ConponentB _conponentB;
        ConponentC _conponentC;
        public ConcreteMediator(ConponentA conponentA, ConponentB conponentB, ConponentC conponentC)
        {
            _conponentA = conponentA;
            _conponentA.SetMediator(this);

            _conponentB = conponentB;
            _conponentB.SetMediator(this);

            _conponentC = conponentC;
            _conponentC.SetMediator(this);
        }

        public void Notify(BaseConponent sender, string param)
        {
            if (param.Equals("A"))
            {
                Console.WriteLine("A notify C");
                _conponentC.DoCElse();
            }
            else if (param.Equals("B"))
            {
                Console.WriteLine("B notify C");
                _conponentC.DoCElse();
            }
            else if (param.Equals("C"))
            {
                Console.WriteLine("C notify AB");
                _conponentA.DoAElse();
                _conponentB.DoBElse();
            }
        }
    }


    //组件 （Component） 是各种包含业务逻辑的类。
    //每个组件都有一个指向中介者的引用， 该引用被声明为中介者接口类型。
    //组件不知道中介者实际所属的类， 因此你可通过将其连接到不同的中介者以使其能在其他程序中复用。
    public abstract class BaseConponent
    {
        protected IMediatorPattern _mediator;
        public BaseConponent(IMediatorPattern mediator = null)
        {
            _mediator = mediator;
        }

        public void SetMediator(IMediatorPattern mediator)
        {
            this._mediator = mediator;
        }
    }

    //组件并不知道其他组件的情况。 如果组件内发生了重要事件， 它只能通知中介者。
    //中介者收到通知后能轻易地确定发送者， 这或许已足以判断接下来需要触发的组件了。
    //对于组件来说， 中介者看上去完全就是一个黑箱。
    //发送者不知道最终会由谁来处理自己的请求， 接收者也不知道最初是谁发出了请求。
    public class ConponentA : BaseConponent
    {
        public ConponentA(IMediatorPattern mediator = null) : base(mediator)
        { }

        public void DoA()
        {
            Console.WriteLine("A Do something");
            this._mediator.Notify(this, "A");
        }

        public void DoAElse()
        {
            Console.WriteLine("A Do something else");
        }
    }

    public class ConponentB : BaseConponent
    {
        public ConponentB(IMediatorPattern mediator = null) : base(mediator)
        { }

        public void DoB()
        {
            Console.WriteLine("B Do something");
            this._mediator.Notify(this, "B");
        }

        public void DoBElse()
        {
            Console.WriteLine("B Do something else");
        }
    }

    public class ConponentC : BaseConponent
    {
        public ConponentC(IMediatorPattern mediator = null) : base(mediator)
        { }

        public void DoC()
        {
            Console.WriteLine("C Do something");
            this._mediator.Notify(this, "C");
        }

        public void DoCElse()
        {
            Console.WriteLine("C Do something else");
        }
    }


    public class MediatorPatternClient
    {
        public static void Test()
        {
            ConponentA conponentA = new ConponentA();
            ConponentB conponentB = new ConponentB();
            ConponentC conponentC = new ConponentC();

            IMediatorPattern mediator = new ConcreteMediator(conponentA, conponentB, conponentC);

            conponentA.DoA();
            conponentB.DoB();
            conponentC.DoC();
        }
    }
}