中介者模式

     一组对象之间的交互非常复杂，同时，每个对象都需要了解本组对象中其他每个对象的情况，那么为一组对象之间提供一个中央权威就非常有意义。当相关对象的交互逻辑独立于对象的其他行为时，把职责进行集中也是非常有意义的。中介者模式就定义了一个对象，这个对象将其他对象的交互进行了封装。这样降低了对象之间的耦合程度，避免了对象之间的相互引用。

结构图[1]如下:

举例如下:

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

namespace MediatorPattern
...{
    /**//// <summary>
    /// 中介者类接口
    /// </summary>
    public interface IMediator
    ...{
        /**//// <summary>
        /// 注册一个操作Message的对象
        /// </summary>
        /// <param name="colleague">Colleague</param>
        void Register(Colleague colleague);

         /**///// <summary>
        /// 发送 Message
        /// </summary>
        /// <param name="source">消息来源对象标识符</param>
        /// <param name="destination">发送目标对象标识符</param>
        /// <param name="message">消息内容</param>
        /// <returns>Message</returns>
        string Send(string source, string destination, string message);
    }

    /**//// <summary>
    /// 中介者类，对其他类的对象交互进行了封装
    /// </summary>
    public class ConcreteMediator : IMediator
    ...{
        private Dictionary<string, Colleague> _dictionary = new Dictionary<string, Colleague>();

        /**///// <summary>
        /// 注册一个操作 Message 的对象
        /// </summary>
        /// <param name="colleague">AbstractMessage</param>
        public void Register(Colleague colleague)
        ...{
            if (!_dictionary.ContainsKey(colleague.UniqueName))
            ...{
                _dictionary.Add(colleague.UniqueName, colleague);
            }
            colleague.CustomConcreteMediator = this;
        }

        /**///// <summary>
        /// 发送 Message
        /// </summary>
        /// <param name="source">消息来源对象标识符</param>
        /// <param name="destination">发送目标对象标识符</param>
        /// <param name="message">消息内容</param>
        /// <returns>Message</returns>
        public string Send(string source, string destination, string message)
        ...{
            string result = string.Empty;
            Colleague colleague = _dictionary[source];
            if (colleague != null)
            ...{
                result = colleague.Insert(destination, message);
            }
            return result;
        }
    }

    /**//// <summary>
    /// 用户抽象类
    /// </summary>
    public abstract class Colleague
    ...{
        private ConcreteMediator _customConcreteMediator;
        private string _uniqueName;

        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="uniqueName">唯一标识符</param>
        public Colleague(string uniqueName)
        ...{
            _uniqueName = uniqueName;
        }

        /**//// <summary>
        /// 唯一标识符
        /// </summary>
        public string UniqueName
        ...{
            get ...{ return _uniqueName; }
        }

        /**//// <summary>
        /// 中介者
        /// </summary>
        public ConcreteMediator CustomConcreteMediator
        ...{
            get ...{ return _customConcreteMediator; }
            set ...{ _customConcreteMediator = value; }
        }

        /**//// <summary>
        /// 发送Message（由客户端调用）
        /// </summary>
        /// <param name="destination">发送目标对象标识符</param>
        /// <param name="message">消息内容</param>
        /// <returns></returns>
        public string Send(string destination, string message)
        ...{
            return _customConcreteMediator.Send(_uniqueName, destination, message);
        }

        /**//// <summary>
        /// 接受Message（由中介者调用）
        /// </summary>
        /// <param name="source">消息来源对象标识符</param>
        /// <param name="message">消息内容</param>
        /// <returns></returns>
        public abstract string Insert(string source, string message);

    }

    /**//// <summary>
    /// 用户类一
    /// </summary>
    public class SqlMessage : Colleague
    ...{
        public SqlMessage(string uniqueName)
            : base(uniqueName)
        ...{ 
        }

        /**//// <summary>
        /// 接受Message（由中介者调用）
        /// </summary>
        /// <param name="source">消息来源对象标识符</param>
        /// <param name="message">消息内容</param>
        /// <returns></returns>
        public override string Insert(string source, string message)
        ...{
            string result = "用户类一提示： 来自 " + source + "的消息：" + message + DateTime.Now.ToString();
            Console.WriteLine(result);
            return result;
        }
    }

    /**//// <summary>
    /// 用户类二
    /// </summary>
    public class XmlMessage : Colleague
    ...{
        public XmlMessage(string uniqueName)
            : base(uniqueName)
        ...{ 
        }

        /**//// <summary>
        /// 接受Message（由中介者调用）
        /// </summary>
        /// <param name="source">消息来源对象标识符</param>
        /// <param name="message">消息内容</param>
        /// <returns></returns>
        public override string Insert(string source, string message)
        ...{
            string result = "用户类二提示： 来自 " + source + "的消息：" + message + DateTime.Now.ToString();
            Console.WriteLine(result);
            return result;
        }
    }

    class Program
    ...{
        static void Main(string[] args)
        ...{
            //中介者对象，它来管理其他对象之间的交互
            IMediator mediator = new ConcreteMediator();

            Colleague user1 = new SqlMessage("user1");
            Colleague user2 = new XmlMessage("user2");

            //所有用户对象先在中介者对象那里报道
            mediator.Register(user1);
            mediator.Register(user2);

            user1.Send("user2", "我是 user1！");
            user2.Send("user1", "我是 user2！");

            Console.ReadLine();
        }
    }
}

(1) http://longhuian.blog.com.cn/archives/2007/2463761.shtml
(2) http://www.cnblogs.com/webabcd/archive/2007/05/19/752808.html