c#之中介者模式

---恢复内容开始---

中介者模式

前言：通过网上查阅资料和最近看的一本书<大话设计模式>，学习了一下中介者模式，接下来我们会通过实例来总结一下中介者模式，加深自己的理解。

中介者模式又叫调停者模式，其实就是中间人或者调停者的意思。

实例：比如说我们国家和国家之间的关系，就比如说今年的中国和印度在边境的问题有一些矛盾，几乎到了无法调和的地步，但是印度最后还是撤军了，因为还是惧怕中国强大的军事实力，但是除了中国自身的实力，另一方面有一个组织也发挥了强大的力量，那就是联合国组织。其实不管是中国，印度，美国，日本，由于各国之间代表的利益不同，所以矛盾冲突是难免的。但是由于联合国组织的成立，它用来维护国际安全，解决国际间经济，社会，文化和人道主义起到了不可磨灭的作用。

这时候我们会想：国与国之间的关系不就是我们不同的对象与对象之间的关系嘛，尽管将一个系统分割成许多对象通常可以增加其复用性，但是对象间的相互连接的激增有会使其降低可复用性。因为大量的连接使得一个对象不可能没有其他对象的支持下工作，系统表现为一个不可分割的整体。所以，对系统的行为进行较大的改动就显得十分的困难了。

这样就引出了我们的中介者设计模式(联合国组织)，截图如下：

中介者模式：每个具体的对象不在直接的联系与另一个对象发生相互作用。而是通过"中介者"对象与另一个对象发生相互作用。中介者对象的设计使得系统的结构不会因为新对象的引入造成大量的修改工作。

下面我们来看一下中介者模式的结构图：

 首先定义我们的抽象的中介者类，代码如下：

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

namespace 中介者模式
{

    /// <summary>
    /// 抽象中介者类
    /// </summary>
    abstract class Mediator
    {
        /// <summary>
        /// 定义一个抽象的发送消息的方法
        /// </summary>
        /// <param name="message">发送消息</param>
        /// <param name="colleague">得到同事对象</param>
        public abstract void Send(string message, Colleague colleague);
    }

}

具体的中介者类，它需要知道所有的同事类，并从具体的同事类接收和发送消息，代码如下：

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

namespace 中介者模式
{
    /// <summary>
    /// 具体的中介者类
    /// </summary>
    class ConcreteMediator : Mediator
    {

        //同事1的引用
        private ConcreteColleague1 concreteColleague1;
        //同事2的引用
        private ConcreteColleague2 concreteColleague2;
        //设置只写属性
        public ConcreteColleague1 ConcreteColleague1
        {
            set { concreteColleague1 = value; }
        }
        public ConcreteColleague2 ConcreteColleague2
        {
            set { concreteColleague2 = value; }
        }
        /// <summary>
        /// 重新发送消息得而方法 根据对象作出选择判断，通知对象
        /// </summary>
        /// <param name="message">发送消息</param>
        /// <param name="colleague">具体的同事对象</param>
        public override void Send(string message, Colleague colleague)
        {
            //如果是同事一发送的消息
            if (colleague == concreteColleague1)
            {
                //同事2进行接收消息
                concreteColleague2.Notify(message);
            }
            else
            {
                //同事2发送消息,同事1接收消息
                concreteColleague1.Notify(message);
            }
        }

    }
}

接下来定义同事类，我们在里面得到中介者的引用，定义发送消息和接收消息的方法，代码如下：

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

namespace 中介者模式
{
    /// <summary>
    /// 抽象同事类
    /// </summary>
    abstract class Colleague
    {

        //中介者的引用
        protected Mediator mediator;
        /// <summary>
        /// 构造函数得到中介者对象
        /// </summary>
        /// <param name="mediator"></param>
        protected Colleague(Mediator mediator)
        {
            this.mediator = mediator;
        }
        /// <summary>
        /// 发送消息的方法
        /// </summary>
        /// <param name="message"></param>
        public abstract void SendMessage(string message);
        /// <summary>
        /// 接收消息的方法
        /// </summary>
        /// <param name="message"></param>
        public abstract void Notify(string message);

    }
}

实现抽象的同事类的具体同事类，代码如下：

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

namespace 中介者模式
{
    /// <summary>
    /// 同事对象1
    /// </summary>
    class ConcreteColleague1 : Colleague
    {

        public ConcreteColleague1(Mediator mediator) : base(mediator) { }

        /// <summary>
        /// 接收消息
        /// </summary>
        /// <param name="message"></param>
        public override void Notify(string message)
        {
            Console.WriteLine("同事一得到消息：{0}", message);
        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="message"></param>
        public override void SendMessage(string message)
        {
            //发送消息时通常是中介者发送出去的
            mediator.Send(message, this);
        }

    }
}

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

namespace 中介者模式
{
    /// <summary>
    /// 同事对象2
    /// </summary>
    class ConcreteColleague2 : Colleague
    {

        public ConcreteColleague2(Mediator mediator) : base(mediator) { }

        /// <summary>
        /// 接收消息
        /// </summary>
        /// <param name="message"></param>
        public override void Notify(string message)
        {
            Console.WriteLine("同事二得到消息：{0}", message);
        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="message"></param>
        public override void SendMessage(string message)
        {
            //发送消息时通常是中介者发送出去的
            mediator.Send(message, this);
        }

    }
}

Main方法的调用：

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

namespace 中介者模式
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteMediator mediator = new ConcreteMediator();
            //让两个具体的同事类认识中介者对象
            ConcreteColleague1 colleague1 = new ConcreteColleague1(mediator);
            ConcreteColleague2 colleague2 = new ConcreteColleague2(mediator);
            //让中介者认识各个具体同事类对象
            mediator.ConcreteColleague1 = colleague1;
            mediator.ConcreteColleague2 = colleague2;
            //具体同事类对象的发送消息都是通过中介者转发
            colleague1.SendMessage("吃饭了吗？");
            colleague2.SendMessage("没有呢，你打算请客？");
            Console.ReadKey();
        }
    }
}

结果如下：

中介者模式的优缺点

优点：首先是Mediator的出现减少了各个Colleague的耦合，使得可以独立的改变和复用各个Colleague和Mediator,比如任何国家的改变不会影响到其他的国家，而只是与联合国发生关系。

缺点：由于ConcreteMediator（具体的中介者类）控制了集中化，于是就把交互的复杂性变成为中介者的复杂性，这就使得中介者会变得比任何的一个ConcreteColleague（具体的同事类）都复杂。

所以我们在用中介者模式的时候应该好好的反思一下在你的系统中是否合理。

中介者模式一般应用于一组对象以定义良好但是复杂的方式进入通信的场合。

---恢复内容结束---