设计模式之中介者模式(Mediator)

中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立里改变他们之间的交互。
Mediator减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator由于把对象如何写作进行了抽象，将中介做为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来，也就是站在一个更宏观的角度去看待系统。由于ConreteMediator控制了集中化，于是就把交互复杂性变为了中介者的复杂性，这样就使得中介者/会变得比任何一个ConcreteColleague都复杂。
中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在各个类中的行为，而又不想生成太多的子类集合。

Mediator1.cs

using System;
using System.Collections.Generic;
using System.Text;

//中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要
//显式地相互引用，从而使其耦合松散，而且可以独立里改变他们之间的交互。
//Mediator减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator
//由于把对象如何写作进行了抽象，将中介做为一个独立的概念并将其封装在一个对象中，这样关注
//的对象就从对象各自本身的行为转移到它们之间的交互上来，也就是站在一个更宏观的角度去看待系统。
//由于ConreteMediator控制了集中化，于是就把交互复杂性变为了中介者的复杂性，这样就使得中介者
//会变得比任何一个ConcreteColleague都复杂。
//中介者模式一般应用于一组对象以定义良好但是复杂的方式进行通信的场合，以及想定制一个分布在各个
//类中的行为，而又不想生成太多的子类集合。
namespace Mediator
{
    class Mediator1
    {
    }
    //Mediator:抽象中介者类
    abstract class Mediator
    {
        public abstract void Send(String message, Colleague colleague);
    }
    //Colleague:抽象同事类
    abstract class Colleague
    {
        protected Mediator mediator;

        public Colleague(Mediator mediator)
        {
            this.mediator = mediator;
        }
    }
    //ConcreteMediator:具体中介者类
    class ConcreteMediator : Mediator
    {
        private ConcreteColleague1 colleague1;
        private ConcreteColleague2 colleague2;

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

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

        public override void Send(string message, Colleague colleague)
        {
            if (colleague == colleague1)
            {
                colleague2.Notify(message);
            }
            else
            {
                colleague1.Notify(message);
            }
        }
    }
    //ConcreteColleague
    class ConcreteColleague1 : Colleague
    {
        public ConcreteColleague1(Mediator mediator) : base(mediator) { }

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

        public void Notify(string message)
        {
            Console.WriteLine("同事1得到信息:" + message);
        }
    }
    class ConcreteColleague2 : Colleague
    {
        public ConcreteColleague2(Mediator mediator) : base(mediator) { }

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

        public void Notify(string message)
        {
            Console.WriteLine("同事2得到信息:" + message);
        }
    } 
}

 

Program.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace Mediator
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteMediator m = new ConcreteMediator();

            ConcreteColleague1 c1 = new ConcreteColleague1(m);
            ConcreteColleague2 c2 = new ConcreteColleague2(m);

            m.Colleague1 = c1;
            m.Colleague2 = c2;

            c1.Send("吃过饭了吗？");
            c2.Send("没有呢，你打算请客？");

            Console.Read();
        }
    }
}

 

运行结果:

同事2得到信息：吃过饭了吗？

同时得到信息：没有呢，你打算请客？