AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

乐在其中设计模式(C#) - 中介者模式(Mediator Pattern)

2014-03-09 932
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 原文:乐在其中设计模式(C#) - 中介者模式(Mediator Pattern)[索引页][源码下载]乐在其中设计模式(C#) - 中介者模式(Mediator Pattern) 作者：webabcd 介绍 用一个中介对象来封装一系列的对象交互。
原文: 乐在其中设计模式(C#) - 中介者模式(Mediator Pattern)

[索引页]
[源码下载]


乐在其中设计模式(C#) - 中介者模式(Mediator Pattern)


作者： webabcd


介绍
用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。


示例
有一个Message实体类，某个对象对它的操作有Send()和Insert()方法，现在用一个中介对象来封装这一系列的对象交互。



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

 namespace  Pattern.Mediator
 {
    /**//// <summary>
    /// Message实体类
    /// </summary>
    public class MessageModel
    {
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="msg">Message内容</param>
        /// <param name="pt">Message发布时间</param>
        public MessageModel(string msg, DateTime pt)
        {
            this._message = msg;
            this._publishTime = pt;
        }

        private string _message;
        /**//// <summary>
        /// Message内容
        /// </summary>
        public string Message
        {
            get { return _message; }
            set { _message = value; }
        }

        private DateTime _publishTime;
        /**//// <summary>
        /// Message发布时间
        /// </summary>
        public DateTime PublishTime
        {
            get { return _publishTime; }
            set { _publishTime = value; }
        }
    }
}

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

 namespace  Pattern.Mediator
 {
    /**//// <summary>
    /// 抽象中介者（Mediator）
    /// </summary>
    public abstract class AbstractMessageMediator
    {
        /**//// <summary>
        /// 注册一个操作Message的对象
        /// </summary>
        /// <param name="AbstractMessage">AbstractMessage</param>
        public abstract void Register(AbstractMessage AbstractMessage);

        /**//// <summary>
        /// 发送Message
        /// </summary>
        /// <param name="from">来自UserId</param>
        /// <param name="to">发送到UserId</param>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public abstract string Send(string from, string to, MessageModel mm);
    }
}

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

 namespace  Pattern.Mediator
 {
    /**//// <summary>
    /// 中介者（ConcreteMediator）
    /// </summary>
    public class MessageMediator : AbstractMessageMediator
    {
        private Dictionary<string, AbstractMessage> _dictionary = new Dictionary<string, AbstractMessage>();

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

            abstractMessage.AbstractMessageMediator = this;
        }

        /**//// <summary>
        /// 发送Message
        /// </summary>
        /// <param name="from">来自UserId</param>
        /// <param name="to">发送到UserId</param>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public override string Send(string from, string to, MessageModel mm)
        {
            AbstractMessage abstractMessage = _dictionary[to];
            if (abstractMessage != null)
            {
                return abstractMessage.Insert(from, mm);
            }
            else
            {
                return null;
            }
        }
    }
}

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

 namespace  Pattern.Mediator
 {
    /**//// <summary>
    /// 操作Message抽象类（Colleague）
    /// </summary>
    public abstract class AbstractMessage
    {
        private AbstractMessageMediator _abstractMessageMediator;
        private string _userId;

        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="userId">UserId</param>
        public AbstractMessage(string userId)
        {
            this._userId = userId;
        }

        /**//// <summary>
        /// UserId
        /// </summary>
        public string UserId
        {
            get { return _userId; }
        }

        /**//// <summary>
        /// 中介者
        /// </summary>
        public AbstractMessageMediator AbstractMessageMediator
        {
            get { return _abstractMessageMediator; }
            set { _abstractMessageMediator = value; }
        }

        /**//// <summary>
        /// 发送Message（由客户端调用）
        /// </summary>
        /// <param name="to">发送到UserId</param>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public string Send(string to, MessageModel mm)
        {
            return _abstractMessageMediator.Send(_userId, to, mm);
        }

        /**//// <summary>
        /// 接受Message（由中介者调用）
        /// </summary>
        /// <param name="from">来自UserId</param>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public abstract string Insert(string from, MessageModel mm);
    }
}

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

 namespace  Pattern.Mediator
 {
    /**//// <summary>
    /// Sql方式操作Message（ConcreteColleague）
    /// </summary>
    public class SqlMessage : AbstractMessage
    {
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="userId">UserId</param>
        public SqlMessage(string userId)
            : base(userId)
        {

        }

        /**//// <summary>
        /// 接受Message（由中介者调用）
        /// </summary>
        /// <param name="from">来自UserId</param>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public override string Insert(string from, MessageModel mm)
        {
            return "Sql方式插入Message（" + from + "发送给" + base.UserId + "）"
                + " - 内容：" + mm.Message
                + " - 时间：" + mm.PublishTime.ToString();
        }
    }
}

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

 namespace  Pattern.Mediator
 {
    /**//// <summary>
    /// Xml方式操作Message（ConcreteColleague）
    /// </summary>
    public class XmlMessage : AbstractMessage
    {
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="userId">UserId</param>
        public XmlMessage(string userId)
            : base(userId)
        {

        }

        /**//// <summary>
        /// 接受Message（由中介者调用）
        /// </summary>
        /// <param name="from">来自UserId</param>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public override string Insert(string from, MessageModel mm)
        {
            return "Xml方式插入Message（" + from + "发送给" + base.UserId + "）"
                + " - 内容：" + mm.Message
                + " - 时间：" + mm.PublishTime.ToString();
        }
    }
}


Test
using  System;
 using  System.Data;
 using  System.Configuration;
 using  System.Collections;
 using  System.Web;
 using  System.Web.Security;
 using  System.Web.UI;
 using  System.Web.UI.WebControls;
 using  System.Web.UI.WebControls.WebParts;
 using  System.Web.UI.HtmlControls;

 using  Pattern.Mediator;

 public  partial  class  Mediator : System.Web.UI.Page
 {
    protected void Page_Load(object sender, EventArgs e)
    {
        AbstractMessageMediator messageMediator = new MessageMediator();

        AbstractMessage user1 = new SqlMessage("user1");
        AbstractMessage user2 = new SqlMessage("user2");
        AbstractMessage user3 = new XmlMessage("user3");
        AbstractMessage user4 = new XmlMessage("user4");

        messageMediator.Register(user1);
        messageMediator.Register(user2);
        messageMediator.Register(user3);
        messageMediator.Register(user4);

        Response.Write(user1.Send("user2", new MessageModel("你好！", DateTime.Now)));
        Response.Write("<br />");
        Response.Write(user2.Send("user1", new MessageModel("我不好！", DateTime.Now)));
        Response.Write("<br />");
        Response.Write(user1.Send("user2", new MessageModel("不好就不好吧。", DateTime.Now)));
        Response.Write("<br />");
        Response.Write(user3.Send("user4", new MessageModel("吃了吗？", DateTime.Now)));
        Response.Write("<br />");
        Response.Write(user4.Send("user3", new MessageModel("没吃，你请我？", DateTime.Now)));
        Response.Write("<br />");
        Response.Write(user3.Send("user4", new MessageModel("不请。", DateTime.Now)));
        Response.Write("<br />");
    }
}

运行结果
Sql方式插入Message（user1发送给user2） - 内容：你好！ - 时间：2007-5-19 23:43:19
Sql方式插入Message（user2发送给user1） - 内容：我不好！ - 时间：2007-5-19 23:43:19
Sql方式插入Message（user1发送给user2） - 内容：不好就不好吧。 - 时间：2007-5-19 23:43:19
Xml方式插入Message（user3发送给user4） - 内容：吃了吗？ - 时间：2007-5-19 23:43:19
Xml方式插入Message（user4发送给user3） - 内容：没吃，你请我？ - 时间：2007-5-19 23:43:19
Xml方式插入Message（user3发送给user4） - 内容：不请。 - 时间：2007-5-19 23:43:19


参考
http://www.dofactory.com/Patterns/PatternMediator.aspx


OK
[源码下载]
文章标签：
C#
SQL
数据格式
XML
索引
设计模式
关键词：
设计模式mediator
设计模式中介者模式
设计模式中介者模式mediator
设计模式pattern
设计模式中介者模式mediator pattern
杰克.陈
目录
相关文章
flzjkl
|
4月前
|
设计模式 Java 程序员
【设计模式】【行为型模式】中介者模式（Mediator）
一、入门 什么是中介者模式？ 中介者模式（Mediator Pattern）是一种行为设计模式，旨在减少对象之间的直接依赖，通过引入一个中介者对象来协调多个对象之间的交互。这种模式特别适用于对象间存在
flzjkl
112 9
wiker24
|
7月前
|
设计模式 供应链 安全
【再谈设计模式】中介者模式 - 协调对象间交互的枢纽
中介者模式定义了一个中介对象来封装一组对象之间的交互方式。中介者使得各对象之间不需要显式地相互引用，从而降低了它们之间的耦合度。它通过将对象之间的交互逻辑集中到中介者对象中，使得系统的结构更加清晰，易于维护和扩展。
wiker24
144 18
【再谈设计模式】中介者模式 - 协调对象间交互的枢纽
游客mh6m5bdpmxyz2
|
6月前
|
设计模式 Java 数据安全/隐私保护
Java 设计模式：装饰者模式（Decorator Pattern）
装饰者模式属于结构型设计模式，允许通过动态包装对象的方式为对象添加新功能，提供比继承更灵活的扩展方式。该模式通过组合替代继承，遵循开闭原则（对扩展开放，对修改关闭）。
游客mh6m5bdpmxyz2
97 1
杀死一只知更鸟debug
|
12月前
|
设计模式
设计模式-工厂模式 Factory Pattern（简单工厂、工厂方法、抽象工厂）
这篇文章详细解释了工厂模式，包括简单工厂、工厂方法和抽象工厂三种类型。每种模式都通过代码示例展示了其应用场景和实现方法，并比较了它们之间的差异。简单工厂模式通过一个工厂类来创建各种产品；工厂方法模式通过定义一个创建对象的接口，由子类决定实例化哪个类；抽象工厂模式提供一个创建相关或依赖对象家族的接口，而不需要明确指定具体类。
杀死一只知更鸟debug
667 0
设计模式-工厂模式 Factory Pattern（简单工厂、工厂方法、抽象工厂）
长梦
|
11月前
|
设计模式 安全 Java
C# 一分钟浅谈：设计模式之单例模式
【10月更文挑战第9天】单例模式是软件开发中最常用的设计模式之一，旨在确保一个类只有一个实例，并提供一个全局访问点。本文介绍了单例模式的基本概念、实现方式（包括饿汉式、懒汉式和使用 `Lazy&lt;T&gt;` 的方法）、常见问题（如多线程和序列化问题）及其解决方案，并通过代码示例详细说明了这些内容。希望本文能帮助你在实际开发中更好地应用单例模式，提高代码质量和可维护性。
长梦
373 1
热爱技术的小郑
|
设计模式 前端开发 Java
【十三】设计模式~~~行为型模式~~~中介者模式（Java）
文章详细介绍了中介者模式（Mediator Pattern），这是一种对象行为型模式，用于封装一系列对象的交互，降低系统耦合度，并简化对象之间的交互关系。通过案例分析、结构图、时序图和代码示例，文章展示了中介者模式的组成部分、实现方式和应用场景，并讨论了其优点、缺点和适用情况。
热爱技术的小郑
183 0
【十三】设计模式~~~行为型模式~~~中介者模式（Java）
追逐时光者
|
设计模式 C# 开发者
C#设计模式入门实战教程
C#设计模式入门实战教程
追逐时光者
112 3
杀死一只知更鸟debug
|
12月前
|
设计模式 Java
设计模式--适配器模式 Adapter Pattern
这篇文章介绍了适配器模式，包括其基本介绍、工作原理以及类适配器模式、对象适配器模式和接口适配器模式三种实现方式。
杀死一只知更鸟debug
399 0
艾利克斯冰
|
12月前
|
设计模式 Java
Java设计模式-中介者模式（20）
Java设计模式-中介者模式（20）
艾利克斯冰
115 0
长梦
|
10月前
|
C# 开发者
C# 一分钟浅谈：Code Contracts 与契约编程
【10月更文挑战第26天】本文介绍了 C# 中的 Code Contracts，这是一个强大的工具，用于通过契约编程增强代码的健壮性和可维护性。文章从基本概念入手，详细讲解了前置条件、后置条件和对象不变量的使用方法，并通过具体代码示例进行了说明。同时，文章还探讨了常见的问题和易错点，如忘记启用静态检查、过度依赖契约和性能影响，并提供了相应的解决建议。希望读者能通过本文更好地理解和应用 Code Contracts。
长梦
193 3

热门文章

最新文章

  • 1
    公司监控软件有哪些？监测方案：基于布隆过滤器的 C# 异常行为检测实践探索
  • 2
    Python设计模式：从代码复用到系统架构的实践指南
  • 3
    Python设计模式：从代码复用到系统架构的实践指南
  • 4
    C# Socket系列二 简单的创建 socket 通信
  • 5
    [C#6] 0-概览
  • 6
    C#的new和CPP的new
  • 7
    C#正则验证字符串是否全是数字
  • 8
    C#并行编程-相关概念
  • 9
    C#基于Socket的简单聊天室实践
  • 10
    .NET(C#) Internals: 以一个数组填充的例子初步了解.NET 4.0中的并行（一）
  • 1
    Python设计模式：从代码复用到系统架构的实践指南
    257
  • 2
    Python设计模式：从代码复用到系统架构的实践指南
    86
  • 3
    【实战指南】设计模式 - 工厂模式
    104
  • 4
    京东二面：说下spring中常用的设计模式？ （一个 深入骨髓的答案， 面试官跪下了）
    276
  • 5
    设计模式觉醒系列(04)策略模式|简单工厂模式的升级版
    246
  • 6
    【高薪程序员必看】万字长文拆解Java并发编程！(8)：设计模式-享元模式设计指南
    99
  • 7
    并发设计模式实战系列(2)：领导者/追随者模式
    123
  • 8
    并发设计模式实战系列(1)：半同步/半异步模式
    103
  • 9
    并发设计模式实战系列(4)：线程池
    301
  • 10
    并发设计模式实战系列(3)：工作队列
    77

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    蛋白质语言模型 ProGen：在实验室合成由 AI 预测的蛋白质