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

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

2014-03-09 909
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 原文:乐在其中设计模式(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
索引
设计模式
关键词：
设计模式中介者模式
设计模式pattern
设计模式mediator
设计模式中介者模式mediator pattern
设计模式mediator pattern
杰克.陈
目录
相关文章
wiker24
|
1月前
|
设计模式 供应链 安全
【再谈设计模式】中介者模式 - 协调对象间交互的枢纽
中介者模式定义了一个中介对象来封装一组对象之间的交互方式。中介者使得各对象之间不需要显式地相互引用，从而降低了它们之间的耦合度。它通过将对象之间的交互逻辑集中到中介者对象中，使得系统的结构更加清晰，易于维护和扩展。
wiker24
53 18
【再谈设计模式】中介者模式 - 协调对象间交互的枢纽
长梦
|
5月前
|
设计模式 安全 Java
C# 一分钟浅谈：设计模式之单例模式
【10月更文挑战第9天】单例模式是软件开发中最常用的设计模式之一，旨在确保一个类只有一个实例，并提供一个全局访问点。本文介绍了单例模式的基本概念、实现方式（包括饿汉式、懒汉式和使用 `Lazy&lt;T&gt;` 的方法）、常见问题（如多线程和序列化问题）及其解决方案，并通过代码示例详细说明了这些内容。希望本文能帮助你在实际开发中更好地应用单例模式，提高代码质量和可维护性。
长梦
188 1
杀死一只知更鸟debug
|
6月前
|
设计模式
设计模式-工厂模式 Factory Pattern（简单工厂、工厂方法、抽象工厂）
这篇文章详细解释了工厂模式，包括简单工厂、工厂方法和抽象工厂三种类型。每种模式都通过代码示例展示了其应用场景和实现方法，并比较了它们之间的差异。简单工厂模式通过一个工厂类来创建各种产品；工厂方法模式通过定义一个创建对象的接口，由子类决定实例化哪个类；抽象工厂模式提供一个创建相关或依赖对象家族的接口，而不需要明确指定具体类。
杀死一只知更鸟debug
207 0
设计模式-工厂模式 Factory Pattern（简单工厂、工厂方法、抽象工厂）
追逐时光者
|
6月前
|
设计模式 C# 开发者
C#设计模式入门实战教程
C#设计模式入门实战教程
追逐时光者
74 3
mingupup
|
7月前
|
设计模式 算法 C#
C#设计模式之策略模式
C#设计模式之策略模式
mingupup
107 19
杀死一只知更鸟debug
|
6月前
|
设计模式 Java
设计模式--适配器模式 Adapter Pattern
这篇文章介绍了适配器模式，包括其基本介绍、工作原理以及类适配器模式、对象适配器模式和接口适配器模式三种实现方式。
杀死一只知更鸟debug
203 0
艾利克斯冰
|
6月前
|
设计模式 Java
Java设计模式-中介者模式（20）
Java设计模式-中介者模式（20）
艾利克斯冰
46 0
热爱技术的小郑
|
7月前
|
设计模式 前端开发 Java
【十三】设计模式~~~行为型模式~~~中介者模式（Java）
文章详细介绍了中介者模式（Mediator Pattern），这是一种对象行为型模式，用于封装一系列对象的交互，降低系统耦合度，并简化对象之间的交互关系。通过案例分析、结构图、时序图和代码示例，文章展示了中介者模式的组成部分、实现方式和应用场景，并讨论了其优点、缺点和适用情况。
热爱技术的小郑
88 0
【十三】设计模式~~~行为型模式~~~中介者模式（Java）
mingupup
|
7月前
|
设计模式 安全 程序员
C#设计模式之单例模式
C#设计模式之单例模式
mingupup
70 3
朝阳39
|
8月前
|
设计模式 JavaScript
js设计模式【详解】—— 中介者模式
js设计模式【详解】—— 中介者模式
朝阳39
100 5

热门文章

最新文章

  • 1
    【再谈设计模式】备忘录模式~对象状态的守护者
  • 2
    【再谈设计模式】中介者模式 - 协调对象间交互的枢纽
  • 3
    设计模式3：代理、适配器、装饰器模式
  • 4
    Python 高级编程与实战：深入理解设计模式与软件架构
  • 5
    设计模式觉醒系列(02)这几种设计模式很简单实用 | 相信你肯定见过
  • 6
    设计模式觉醒系列(01)设计模式的基石 | 六大原则的核心是什么?
  • 7
    设计模式：工厂方法模式（Factory Method）
  • 8
    【再谈设计模式】访问者模式~操作对象结构的新视角
  • 9
    浅谈几种js设计模式
  • 10
    【再谈设计模式】解释器模式~语法的解析执行者
  • 1
    C#之 Dictionary 详解
    17
  • 2
    基于 C# 网络套接字算法的局域网实时监控技术探究
    31
  • 3
    多种脚本批量下载 Docker 镜像：Shell、PowerShell、Node.js 和 C#
    77
  • 4
    掌握 LINQ：通过示例解释 C# 中强大的 LINQ的集运算
    36
  • 5
    C#字符串拼接的6种方式及其性能分析对比
    43
  • 6
    C# 中关于补位的写法 PadLeft，PadRight 函数
    72
  • 7
    c# 创建文件夹
    49
  • 8
    C# Hashtable的用法
    31
  • 9
    Unity C#for和foreach效率比较
    25
  • 10
    C#实现上位机开发，串口通信，读写串口数据并处理16进制数据
    259

    • 相关课程

    更多
  • 5天玩转Java面向对象编程
  • Java面向对象编程
  • Java面向对象开发

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    阿里云负载均衡SLB版本CLB、ALB和NLB有什么区别如何选择？