在本文中，我们将给您介绍关于中介模式Mediator的详细内容，并且为您解答中介模式和代理模式的区别的相关问题，此外，我们还将为您提供关于.Net行为型设计模式之中介者模式（Mediator）、23、
在本文中，我们将给您介绍关于中介模式Mediator的详细内容，并且为您解答中介模式和代理模式的区别的相关问题，此外，我们还将为您提供关于.Net行为型设计模式之中介者模式（Mediator）、23、行为型 - 中介者模式（Mediator）、C#设计模式之Mediator中介者模式解决程序员的七夕缘分问题示例、C#设计模式之十七中介者模式（Mediator Pattern）【行为型】的知识。
本文目录一览：- 中介模式Mediator（中介模式和代理模式的区别）
- .Net行为型设计模式之中介者模式（Mediator）
- 23、行为型 - 中介者模式（Mediator）
- C#设计模式之Mediator中介者模式解决程序员的七夕缘分问题示例
- C#设计模式之十七中介者模式（Mediator Pattern）【行为型】
中介模式Mediator（中介模式和代理模式的区别）
一 概述
中介，是作为多个事物之间充当交互沟通的媒介，在程序也是这样的，对象与对象之间不需要持有对方引用，而是通过中介相互连接；
二 使用示例
使用聊天室作为中介，支持用户登录、用户注销、用户发言；
package cn.hello;
/**
* 聊天室里的用户
*
* @author:wjm
* @date:2020/6/23 22:41
*/
public class User {
/**
* 用户名字
*/
private String name;
/**
* 聊天室引用
*/
private ChatRoom chatRoom;
/**
* 限制创建用户时必须起名字
*
* @param name
*/
public User(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
/**
* 用户登陆
*
* @param chatRoom
*/
public void login(ChatRoom chatRoom) {
//连接到聊天室
chatRoom.connect(this);
//注入聊天室引用
this.chatRoom = chatRoom;
}
/**
* 用户注销
*
* @param chatRoom
*/
public void logout(ChatRoom chatRoom) {
//连接到聊天室
chatRoom.disconnect(this);
//销毁聊天室
this.chatRoom = null;
}
/**
* 用户发言
*
* @param msg
*/
public void talk(String msg) {
if (chatRoom == null) {
System.out.println("用户" + this.name + "已退出，无法继续发言");
return;
}
//给聊天室发消息(绑定了用户与信息)
chatRoom.sendMsg(this, msg);
}
/**
* 接收信息
*
* @param fromWhom
* @param msg
*/
public void receive(User fromWhom, String msg) {
System.out.println("【" + this.name + "的对话框】" + fromWhom.getName() + " 说： " + msg);
}
}
package cn.hello;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 聊天室
*
* @author:wjm
* @date:2020/6/23 22:47
*/
public class ChatRoom {
/**
* 聊天室名字
*/
private String name;
/**
* 聊天室里的用户们
*/
List<User> userList = new ArrayList<>();
/**
* 限制创建聊天室时必须起名字
*
* @param name
*/
public ChatRoom(String name) {
this.name = name;
}
/**
* 连接聊天室，用户加入
*
* @param user
*/
public void connect(User user) {
//将用户加入聊天室列表
userList.add(user);
System.out.println("欢迎【" + user.getName() + "】加入聊天室【" + this.name + "】");
}
/**
* 离开聊天室，用户退出
*
* @param user
*/
public void disconnect(User user) {
//将用户从聊天室列表移出
Iterator<User> iterator = userList.iterator();
while (iterator.hasNext()) {
User userInChatRoom = iterator.next();
if (userInChatRoom == user) {
iterator.remove();
}
}
System.out.println("【" + user.getName() + "】离开聊天室【" + this.name + "】");
}
/**
* 发送信息 给 聊天室里 除了发送方之外的 其他所有用户
*
* @param fromWhom
* @param msg
*/
public void sendMsg(User fromWhom, String msg) {
userList.stream().filter(user ->
//过滤掉发送方fromWhom
!user.equals(fromWhom))
//发送消息给剩下的所有人
.forEach(toWhom -> toWhom.receive(fromWhom, msg));
}
}
package cn.hello;
/**
* 应用
*
* @author:wjm
* @date:2020/6/23 22:56
*/
public class Test {
public static void main(String[] args) {
ChatRoom chatRoom = new ChatRoom("聊天室1");
User user1 = new User("小明1");
User user2 = new User("小明2");
User user3 = new User("小明3");
User user4 = new User("小明4");
User user5 = new User("小明5");
User user6 = new User("小明6");
User user7 = new User("小明7");
User user8 = new User("小明8");
User user9 = new User("小明9");
user1.login(chatRoom);
user2.login(chatRoom);
user3.login(chatRoom);
user4.login(chatRoom);
user5.login(chatRoom);
user6.login(chatRoom);
user7.login(chatRoom);
user8.login(chatRoom);
user9.login(chatRoom);
System.out.println();
user1.talk("大家好，我来了");
System.out.println();
user3.logout(chatRoom);
user4.logout(chatRoom);
user5.logout(chatRoom);
user6.logout(chatRoom);
user7.logout(chatRoom);
user8.logout(chatRoom);
user9.logout(chatRoom);
System.out.println();
//测试注销是否生效
user3.talk("大家好，我来了");
/*************************以下为输出************************/
/*
欢迎【小明1】加入聊天室【聊天室1】
欢迎【小明2】加入聊天室【聊天室1】
欢迎【小明3】加入聊天室【聊天室1】
欢迎【小明4】加入聊天室【聊天室1】
欢迎【小明5】加入聊天室【聊天室1】
欢迎【小明6】加入聊天室【聊天室1】
欢迎【小明7】加入聊天室【聊天室1】
欢迎【小明8】加入聊天室【聊天室1】
欢迎【小明9】加入聊天室【聊天室1】
【小明2的对话框】小明1 说： 大家好，我来了
【小明3的对话框】小明1 说： 大家好，我来了
【小明4的对话框】小明1 说： 大家好，我来了
【小明5的对话框】小明1 说： 大家好，我来了
【小明6的对话框】小明1 说： 大家好，我来了
【小明7的对话框】小明1 说： 大家好，我来了
【小明8的对话框】小明1 说： 大家好，我来了
【小明9的对话框】小明1 说： 大家好，我来了
【小明3】离开聊天室【聊天室1】
【小明4】离开聊天室【聊天室1】
【小明5】离开聊天室【聊天室1】
【小明6】离开聊天室【聊天室1】
【小明7】离开聊天室【聊天室1】
【小明8】离开聊天室【聊天室1】
【小明9】离开聊天室【聊天室1】
用户小明3已退出，无法继续发言
*/
}
}
以上只是最简单的聊天室发言方式，如果需求变得复杂，例如有了不同的用户，或是聊天室也各不相同并加入了各自的特性，那我们就需要继续重构，抽象聊天室类，抽象用户类，读者可以灵活运用等；
三 总结
中介模式不止是在生活中广泛应用，在软件架构中也非常常见，如微服务分布式软件架构所用到的注册中心Eureka，其作用就是为众多分布式服务提供注册发现服务，它充当了像中介一样的角色；
组合模式属于树型结构：它主要描述的是子节点与父节点的关系：
中介模式属于网络拓扑中的星型结构，它描述了众节点与中心点的关系：
对像之间显式地互相引用越多，意味着依赖性越强，独立性越差，不利于代码维护与扩展，同时多方沟通的任务也应交由中间平台来完成，每个类应只具备各自该有的功能，这便是高内聚低耦合的设计标准；
中介模式符合迪米特法则，它解决了对象间过度耦合、复杂频繁交互的问题，打破了你中有我，我中有你的相互依赖，第三方的介入有助于双方调停，打破如胶似漆、纠缠不休的关系，让他们之间变得松散、自由、独立；
四 类UML图
源码地址：我的GitHub
.Net行为型设计模式之中介者模式（Mediator）
一、动机（Motivate）
为什么要使用中介者模式呢？如果不使用中介者模式的话，各个同事对象将会相互进行引用，如果每个对象都与多个对象进行交互时，将会形成如下图所示的网状结构。
从上图可以发现，如果不使用中介者模式的话，每个对象之间过度耦合，这样的既不利于类的复用也不利于扩展。如果引入了中介者模式，那么对象之间的关系将变成星型结构，采用中介者模式之后会形成如下图所示的结构：
从上图可以发现，使用中介者模式之后，任何一个类的变化，只会影响中介者和类本身，不像之前的设计，任何一个类的变化都会引起其关联所有类的变化。这样的设计大大减少了系统的耦合度。
在软件构建过程中，经常会出现多个对象互相关联交互的情况，对象之间常常会维持一种复杂的引用关系，如果遇到一些需求的更改，这种直接的引用关系将面临不断地变化。
在这种情况下，我们可使用一个“中介对象”来管理对象间的关联关系，避免相互交互的对象之间的紧耦合引用关系，从而更好地抵御变化。
二、意图（Intent）
定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立地改变它们之间的交互行为。 ——《设计模式》GoF
三、结构图（Structure）
四、模式的组成
可以看出，在中介者模式的结构图有以下角色：
（1）、抽象中介者角色（Mediator）：在里面定义各个同事之间交互需要的方法，可以是公共的通信方法，也可以是小范围的交互方法。
（2）、具体中介者角色（ConcreteMediator）：它需要了解并维护各个同事对象，并负责具体的协调各同事对象的交互关系。
（3）、抽象同事类（Colleague）：通常为抽象类，主要约束同事对象的类型，并实现一些具体同事类之间的公共功能，比如，每个具体同事类都应该知道中介者对象，也就是具体同事类都会持有中介者对象，都可以到这个类里面。
（4）、具体同事类（ConcreteColleague）：实现自己的业务，需要与其他同事通信时候，就与持有的中介者通信，中介者会负责与其他同事类交互。
五、中介者模式的代码实现
中介者模式在现实生活中也有类似的例子，不论是QQ群或者是微信群，或者手提电话，它们都是充当一个中间平台，QQ用户可以登录这个中间平台与其他QQ用户进行交流，如果没有这些中间平台，我们如果想与朋友进行聊天的话，可能就需要当面才可以了。比如：在公司管理过程中，就会涉及到各个部门之间的协调和合作，如何各个部门直接来沟通，看着好像直接高效，其实不然。各个部门之间为了完成一个工作，沟通协调就需要一个人来做这个工作，谁呢？总经理，我们这里就把总经理定义为成总的管理者，各个部门需要向他汇报和发起工作请求。
static void Main(String[] args)
{
President mediator = new President();
Market market = new Market(mediator);
Development development = new Development(mediator);
Financial financial = new Financial(mediator);
mediator.SetFinancial(financial);
mediator.SetDevelopment(development);
mediator.SetMarket(market);
market.Process();
market.Apply();
}
//抽象中介者角色
public interface Mediator
{
void Command(Department department);
}
//总经理--相当于具体中介者角色
public sealed class President : Mediator
{
//总经理有各个部门的管理权限
private Financial _financial;
private Market _market;
private Development _development;
public void SetFinancial(Financial financial)
{
this._financial = financial;
}
public void SetDevelopment(Development development)
{
this._development = development;
}
public void SetMarket(Market market)
{
this._market = market;
}
public void Command(Department department)
{
if (department.GetType() == typeof(Market))
{
_financial.Process();
}
}
}
//同事类的接口
public abstract class Department
{
//持有中介者(总经理)的引用
private Mediator mediator;
protected Department(Mediator mediator)
{
this.mediator = mediator;
}
public Mediator GetMediator
{
get { return mediator; }
private set { this.mediator = value; }
}
//做本部门的事情
public abstract void Process();
//向总经理发出申请
public abstract void Apply();
}
//开发部门
public sealed class Development : Department
{
public Development(Mediator m) : base(m) { }
public override void Process()
{
Console.WriteLine("我们是开发部门，要进行项目开发，没钱了，需要资金支持！");
}
public override void Apply()
{
Console.WriteLine("专心科研，开发项目！");
}
}
//财务部门
public sealed class Financial : Department
{
public Financial(Mediator m) : base(m) { }
public override void Process()
{
Console.WriteLine("汇报工作！没钱了，钱太多了！怎么花?");
}
public override void Apply()
{
Console.WriteLine("数钱！");
}
}
//市场部门
public sealed class Market : Department
{
public Market(Mediator mediator) : base(mediator) { }
public override void Process()
{
Console.WriteLine("汇报工作！项目承接的进度，需要资金支持！");
GetMediator.Command(this);
}
public override void Apply()
{
Console.WriteLine("跑去接项目！");
}
}六、中介者模式的实现要点：
将多个对象间复杂的关联关系解耦，Mediator模式将多个对象间的控制逻辑进行集中管理，变“多个对象互相关联”为“多个对象和一个中介者关联”，简化了系统的维护，抵御了可能的变化。随着控制逻辑的复杂化，Mediator具体对象的实现可能相当复杂。这时候可以对Mediator对象进行分解处理。
- Facade模式是解耦系统外到系统内（单向）的对相关联关系
- Mediator模式是解耦系统内各个对象之间（双向）的关联关系
1、中介者模式的优点
（1）、松散耦合：中介者模式通过把多个同事对象之间的交互封装到中介对象里面，从而使得对象之间松散耦合，基本上可以做到互不依赖。这样一来，同时对象就可以独立的变化和复用，不再“牵一发动全身”
（2）、集中控制交互：多个同事对象的交互，被封装在中介者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改中介者就可以了。
（3）、多对多变为一对多：没有中介者模式的时候，同事对象之间的关系通常是多对多，引入中介者对象后，中介者和同事对象的关系通常变为双向的一对多，这会让对象的关系更容易理解和实现。
2、中介者模式的缺点
过多集中化：如果同事对象之间的交互非常多，而且比较复杂，当这些复杂性全都集中到中介者的时候，会导致中介者对象变的十分复杂，而且难于维护和管理。
七、.NET 中介者模式的实现
根据我个人的理解，微软的ASP.NET MVC开发模式就是一个中介者模式的很好的实现，其中C就是Controller，也就是中文所说的控制器，控制器就是一个中介者，M和V和它打交道，具体的情况大家可以去查看相关资料，这方面的资料还是很多的。
到此这篇关于.Net行为型设计模式之中介者模式（Mediator）的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。
- .Net行为型设计模式之备忘录模式（Memento）
- .Net行为型设计模式之访问者模式（Visitor）
- .Net行为型设计模式之职责链模式（Chain of Responsibility）
- .Net行为型设计模式之策略模式（Stragety）
- .Net行为型设计模式之状态模式（State）
- .Net行为型设计模式之观察者模式（Observer）
- .Net行为型设计模式之迭代器模式（Iterator）
- .Net行为型设计模式之命令模式（Command）
- .Net行为型设计模式之模板方法模式（Template Method）
- .Net行为型设计模式之解释器模式（Interpreter）
23、行为型 - 中介者模式（Mediator）
中介者模式 (Mediator Pattern)：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。
中介者模式包含如下几个角色：
● Mediator（抽象中介者）：它定义一个接口，该接口用于与各同事对象之间进行通信。
● ConcreteMediator（具体中介者）：它是抽象中介者的子类，通过协调各个同事对象来实现协作行为，它维持了对各个同事对象的引用。
● Colleague（抽象同事类）：它定义各个同事类公有的方法，并声明了一些抽象方法来供子类实现，同时它维持了一个对抽象中介者类的引用，其子类可以通过该引用来与中介者通信。
● ConcreteColleague（具体同事类）：它是抽象同事类的子类；每一个同事对象在需要和其他同事对象通信时，先与中介者通信，通过中介者来间接完成与其他同事类的通信；在具体同事类中实现了在抽象同事类中声明的抽象方法
1、主要优点
(1) 中介者模式简化了对象之间的交互，它用中介者和同事的一对多交互代替了原来同事之间的多对多交互，一对多关系更容易理解、维护和扩展，将原本难以理解的网状结构转换成相对简单的星型结构。
(2) 中介者模式可将各同事对象解耦。中介者有利于各同事之间的松耦合，我们可以独立的改变和复用每一个同事和中介者，增加新的中介者和新的同事类都比较方便，更好地符合“开闭原则”。
(3) 可以减少子类生成，中介者将原本分布于多个对象间的行为集中在一起，改变这些行为只需生成新的中介者子类即可，这使各个同事类可被重用，无须对同事类进行扩展。
2、主要缺点
在具体中介者类中包含了大量同事之间的交互细节，可能会导致具体中介者类非常复杂，使得系统难以维护。
3、适用场景
(1) 系统中对象之间存在复杂的引用关系，系统结构混乱且难以理解。
(2) 一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。
(3) 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象交互的公共行为，如果需要改变行为则可以增加新的具体中介者类。
我们就以租房为例，中介机构充当租房者与房屋所有者之间的中介者
/**
* 2018/12/6
* 抽象中介者
*
* @author machuanpeng
*/
public abstract class Mediator {
//申明一个联络方法
public abstract void constact(String message,Person person);
}
/**
* 2018/12/6
* 抽象同事对象
*
* @author machuanpeng
*/
public abstract class Person {
protected String name;
protected Mediator mediator;
Person() {}
Person(String name, Mediator mediator) {
this.name = name;
this.mediator = mediator;
}
/**与中介者联系*/
public void constact(String message){
mediator.constact(message, this);
}
/**获取信息*/
public void getMessage(String message);
public void getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public void getMediator() {
return this.mediator;
}
public void setMediator(Mediator mediator) {
this.mediator = mediator;
}
}
/**
* 2018/12/6
* 房主
*
* @author machuanpeng
*/
public class HouseOwner extends Person{
HouseOwner(String name, Mediator mediator) {
super(name, mediator);
}
public void getMessage(String message){
System.out.println("房主:" + name +",获得信息：" + message);
}
}
/**
* 2018/12/6
* 租客
*
* @author machuanpeng
*/
public class Renter extends Person{
Renter(String name, Mediator mediator) {
super(name, mediator);
}
public void getMessage(String message){
System.out.println("租客:" + name +",获得信息：" + message);
}
}
/**
* 2018/12/6
* 具体中介者对象
*
* @author machuanpeng
*/
public class MediatorStructure extends Mediator{
//首先中介结构必须知道所有房主和租房者的信息
private HouseOwner houseOwner;
private Renter renter;
public void constact(String message, Person person) {
if(person == houseOwner){
//如果是房主，则租房者获得信息
renter.getMessage(message);
}else{
//反正则是房主获得信息
houseOwner.getMessage(message);
}
}
public HouseOwner getHouseOwner() {
return houseOwner;
}
public void setHouseOwner(HouseOwner houseOwner) {
this.houseOwner = houseOwner;
}
public Renter getRenter() {
return renter;
}
public void setRenter(Renter renter) {
this.renter = renter;
}
}
测试：
public class Client {
public static void main(String[] args) {
//一个房主、一个租房者、一个中介机构
MediatorStructure mediator = new MediatorStructure();
//房主和租房者只需要知道中介机构即可
HouseOwner houseOwner = new HouseOwner("张三", mediator);
Renter renter = new Renter("李四", mediator);
//中介结构要知道房主和租房者
mediator.setHouseOwner(houseOwner);
mediator.setRenter(renter);
renter.constact("听说你那里有三室的房主出租.....");
houseOwner.constact("是的!请问你需要租吗?");
}
}
C#设计模式之Mediator中介者模式解决程序员的七夕缘分问题示例
本文实例讲述了C#设计模式之Mediator中介者模式解决程序员的七夕缘分问题。分享给大家供大家参考，具体如下：
一、理论定义
中介者模式 定义了一种一对多的操作，解脱了对象之间多对多的引用依赖，所有对象之间的通信，都封装在 中介者里面。
二、应用举例
需求描述： 七夕来啦，谁说程序员就一定 是单身苦逼呢，程序员也有自己的幸福。
也在追寻自己的缘分，我们都是有理想，有文化，有独立见解的群体，
我们为 信息社会所做的努力，能给我们七夕带来好运。告别单身，开始行动啦！
1.三个程序员 找到了 缘分"YuanFen"大师，希望找到自己另一半，
2.六个美女： 刘诗诗,蒋琴琴，白富美，朱莉，舒淇，语嫣 也找到 缘分"YuanFen" 大师，
希望心中的 白马王子能给自己一注目光。
3.缘分大师 接受了程序员 和 美女的请求。
4.开始缘分派对啦！
三、具体编码
1.美女们(Grils)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Com.Design.Gof.Mediator
{
public class Girls
{
/// <summary>
/// 美女名字
/// </summary>
public string Name { get; set; }
/// <summary>
/// 找了一个叫“缘分” 的中介者 做媒婆
/// </summary>
public YuanFen YuanFen { get; set; }
/// <summary>
/// 向自己心目中的 白马王子发信
/// </summary>
/// <param name="name_message">名字和信息</param>
public void SendMessage(Dictionary<string,string> name_message) {
YuanFen.SendToBoys(name_message);
}
/// <summary>
/// 收到某个白马王子回信
/// </summary>
public void RecieveMessage(string msg)
{
Console.WriteLine(msg);
}
}
}
2. 帅哥程序员
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Com.Design.Gof.Mediator
{
/// <summary>
/// 帅哥 1
/// </summary>
public class Boys
{
/// <summary>
/// 帅哥名字
/// </summary>
public string Name { get; set; }
/// <summary>
/// 找了一个叫“缘分” 的中介者 做媒婆
/// </summary>
public YuanFen YuanFen { get; set; }
/// <summary>
///向自己心目中的 白雪公主发信
/// </summary>
/// <param name="name_message">名字和信息</param>
public void SendMessage(Dictionary<string, string> name_message)
{
YuanFen.SendToGrils(name_message);
}
/// <summary>
/// 收到某个白雪公主回信
/// </summary>
public void RecieveMessage(string msg)
{
Console.WriteLine(msg);
}
}
}
3.缘分
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Com.Design.Gof.Mediator
{
public class YuanFen
{
public List<Girls> Girls { get; set; }
public List<Boys> Boys { get; set; }
/// <summary>
/// 男孩向女孩发信
/// </summary>
/// <param name="name_message"></param>
public void SendToGrils(Dictionary<string, string> name_message)
{
foreach (var k in name_message) {
foreach (var girl in Girls) {
if (k.Key == girl.Name) {
girl.RecieveMessage(k.Value);
}
}
}
}
/// <summary>
/// 女孩向男孩发信
/// </summary>
/// <param name="name_message"></param>
public void SendToBoys(Dictionary<string, string> name_message)
{
foreach (var k in name_message)
{
foreach (var boy in Boys)
{
if (k.Key == boy.Name)
{
boy.RecieveMessage(k.Value);
}
}
}
}
}
}
4.主函数(派对，发情书)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Com.Design.Gof.Mediator;
namespace Com.Design.Gof.Test
{
class Program
{
static void Main(string[] args)
{
//缘分 这个 媒婆来了
YuanFen yuanFen = new YuanFen { Boys=new List<Boys>(), Girls=new List<Girls>()};
//男孩子们雀跃报名啊
Boys boy1 = new Boys { Name="程序员1", YuanFen=yuanFen};
Boys boy2 = new Boys { Name = "程序员2", YuanFen = yuanFen };
Boys boy3 = new Boys { Name = "程序员3", YuanFen = yuanFen };
//缘分接受了男孩子的夙愿
yuanFen.Boys.Add(boy1); yuanFen.Boys.Add(boy2); yuanFen.Boys.Add(boy3);
//女孩子也很积极
Girls girls1 = new Girls { Name="刘诗诗", YuanFen=yuanFen};
Girls girls2 = new Girls { Name = "白富美", YuanFen = yuanFen };
Girls girls3 = new Girls { Name = "蒋琴琴", YuanFen = yuanFen };
Girls girls4 = new Girls { Name = "舒淇", YuanFen = yuanFen };
Girls girls5 = new Girls { Name = "朱莉", YuanFen = yuanFen };
Girls girls6 = new Girls { Name = "语嫣", YuanFen = yuanFen };
//缘分接受了美女们的爱情 丘比特
yuanFen.Girls.Add(girls1); yuanFen.Girls.Add(girls2); yuanFen.Girls.Add(girls3);
yuanFen.Girls.Add(girls4); yuanFen.Girls.Add(girls5); yuanFen.Girls.Add(girls6);
//开始派对啦
//程序员1 对 刘诗诗,蒋琴琴 感兴趣
Dictionary<string, string> name_message = new Dictionary<string, string>();
name_message.Add("刘诗诗", boy1.Name + " 对刘诗诗说： 诗诗诗诗 我爱你，就像老鼠爱大米");
name_message.Add("蒋琴琴", boy1.Name + " 对蒋琴琴说： 我希望每天睡前最后看到的人是你...... ");
boy1.SendMessage(name_message);
name_message.Clear();
Console.WriteLine();
//程序员2 对 刘诗诗,朱莉，舒淇 感兴趣
name_message.Add("语嫣", boy2.Name + " 对语嫣说： 地球仍然转动，世界依旧善变，而我永远爱你");
name_message.Add("朱莉", boy2.Name + " 对朱莉说： 每天都 ...很想妳... ");
name_message.Add("舒淇", boy2.Name + " 对舒淇说： 曾经迷惘的心中，是你牵引我走出寂寞 ");
boy2.SendMessage(name_message);
name_message.Clear();
Console.WriteLine();
//语嫣 对三个程序员都感兴趣
name_message.Add("程序员1", girls6.Name + " 对程序员1说： 想想和我一起看日升日落的喜悦吧！...嘻嘻");
name_message.Add("程序员2", girls6.Name + " 对程序员2说： 我的世界只有你懂.... ");
name_message.Add("程序员3", girls6.Name + " 对程序员3说： 因为知道不能没有你，所以会更珍惜 ");
girls6.SendMessage(name_message);
name_message.Clear();
Console.WriteLine();
//蒋琴琴 很钟情，很专一，只给程序员1 发信
name_message.Add("程序员1", girls3.Name + " 对程序员1说： 爱你一生伴你一世，你的心跳只有我听得到");
girls3.SendMessage(name_message);
Console.ReadKey();
}
}
}
5.运行结果
6.总结
七夕来了，找回自己的缘分。
附：完整实例代码点击此处本站下载。
更多关于C#相关内容还可查看本站专题：《C#数据结构与算法教程》、《C#窗体操作技巧汇总》、《C#常见控件用法教程》、《WinForm控件用法总结》、《C#数组操作技巧总结》及《C#面向对象程序设计入门教程》
希望本文所述对大家C#程序设计有所帮助。
- 详解C#设计模式编程中生成器模式的使用
- C#设计模式之Template模板方法模式实现ASP.NET自定义控件 密码强度检测功能
- C#设计模式之Visitor访问者模式解决长隆欢乐世界问题实例
- C#设计模式之Strategy策略模式解决007大破密码危机问题示例
- C#设计模式之ChainOfResponsibility职责链模式解决真假美猴王问题实例
- C#设计模式之Observer观察者模式解决牛顿童鞋成绩问题示例
- C#设计模式之单例模式实例讲解
- c#设计模式 适配器模式详细介绍
- C#设计模式之观察者模式实例讲解
- 实例解析C#设计模式编程中简单工厂模式的使用
- C#设计模式之外观模式介绍
- C#设计模式之Builder生成器模式解决带老婆配置电脑问题实例
C#设计模式之十七中介者模式（Mediator Pattern）【行为型】
一、引言
今天我们开始讲“行为型”设计模式的第五个模式，该模式是【中介者模式】，英文名称是：Mediator Pattern。还是老套路，先从名字上来看看。“中介者模式”我第一次看到这个名称，我的理解是，在两个对象中间增加一个“中间对象”，“中间对象”协调两个对象的关系，但是随着理解的深入，“中间对象”处理关系的对象可能不只是两个对象，可能是三个对象，或者更多对象。中介者模式在现实生活中的例子很多，比如：A对象和B对象做生意，如果A对象和B对象是一次性买卖，没有讨价还价的过程，A对象和B对象直接见面更好。但是A对象或者B对象的想法经常变，每次想法的改变都通知对方，就会使对方很反感，而且也不利于生意的顺利进行。如果在A对象和B对象之间增加一个C对象，在最终确定之前不要告诉C对象，对方也就不知道（隔离了耦合，对方可以更具需求变化），等一方最终确定想法后，把最后决定告诉C对象，C对象再转告对方，这样就简化了A对象和B对象的交易过程，而且双方都很满意。在软件构建过程中，因为有了变化，才有增加中介者的需要，如果没有变化，可以一次搞定，直接硬编码也没关系，所以说“变化”是模式的前提，无论是什么模式，就因为有变化，我们需要抵御变化，才要使用相应的模式来解决问题。
二、中介者模式的详细介绍
2.1、动机（Motivate）
在软件构建过程中，经常会出现多个对象互相关联交互的情况，对象之间常常会维持一种复杂的引用关系，如果遇到一些需求的更改，这种直接的引用关系将面临不断地变化。
在这种情况下，我们可使用一个“中介对象”来管理对象间的关联关系，避免相互交互的对象之间的紧耦合引用关系，从而更好地抵御变化。
2.2、意图（Intent）
定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用，从而使耦合性降低，而且可以独立地改变它们之间的交互行为。 ——《设计模式》GoF
2.3、结构图（Structure）
2.4、模式的组成
可以看出，在中介者模式的结构图有以下角色：
（1）、抽象中介者角色（Mediator）：在里面定义各个同事之间交互需要的方法，可以是公共的通信方法，也可以是小范围的交互方法。
（2）、具体中介者角色（ConcreteMediator）：它需要了解并维护各个同事对象，并负责具体的协调各同事对象的交互关系。
（3）、抽象同事类（Colleague）：通常为抽象类，主要约束同事对象的类型，并实现一些具体同事类之间的公共功能，比如，每个具体同事类都应该知道中介者对象，也就是具体同事类都会持有中介者对象，都可以到这个类里面。
（4）、具体同事类（ConcreteColleague）：实现自己的业务，需要与其他同事通信时候，就与持有的中介者通信，中介者会负责与其他同事类交互。
2.5、中介者模式的代码实现
中介者模式在现实生活中也有类似的例子，不论是QQ群或者是微信群，或者手提电话，它们都是充当一个中间平台，QQ用户可以登录这个中间平台与其他QQ用户进行交流，如果没有这些中间平台，我们如果想与朋友进行聊天的话，可能就需要当面才可以了。比如：在公司管理过程中，就会涉及到各个部门之间的协调和合作，如何各个部门直接来沟通，看着好像直接高效，其实不然。各个部门之间为了完成一个工作，沟通协调就需要一个人来做这个工作，谁呢？总经理，我们这里就把总经理定义为成总的管理者，各个部门需要向他汇报和发起工作请求。我们看代码吧，实现代码如下：
1 namespace 中介者模式的实现 2 { 3 //抽象中介者角色 4 public interface Mediator 5 { 6 void Command(Department department); 7 } 8 9 总经理--相当于具体中介者角色 10 sealed class President : Mediator 11 12 总经理有各个部门的管理权限 13 private Financial _financial; 14 Market _market; 15 Development _development; 16 17 SetFinancial(Financial financial) 18 { 19 this._financial = financial; 20 } 21 SetDevelopment(Development development) 22 23 this._development = development; 24 25 SetMarket(Market market) 26 27 this._market = market; 28 29 30 Command(Department department) 31 32 if (department.GetType() == typeof(Market)) 33 { 34 _financial.Process(); 35 } 36 37 38 39 同事类的接口 40 abstract Department 41 42 持有中介者(总经理)的引用 43 Mediator mediator; 44 45 protected Department(Mediator mediator) 46 47 this.mediator = mediator; 48 49 50 public Mediator GetMediator 51 52 get { return mediator; } 53 private set { value; } 54 55 56 做本部门的事情 57 Process(); 58 59 向总经理发出申请 60 Apply(); 61 62 63 开发部门 64 Development : Department 65 66 public Development(Mediator m) : base(m) { } 67 68 override Process() 69 70 Console.WriteLine("我们是开发部门，要进行项目开发，没钱了，需要资金支持！"); 71 72 73 Apply() 74 75 Console.WriteLine(专心科研，开发项目！ 76 77 78 79 财务部门 80 Financial : Department 81 82 public Financial(Mediator m) : 83 84 85 86 Console.WriteLine(汇报工作！没钱了，钱太多了！怎么花? 87 88 89 90 91 Console.WriteLine(数钱！ 92 93 94 95 市场部门 96 Market : Department 97 98 public Market(Mediator mediator) : (mediator) { } 99 100 101 102 Console.WriteLine(汇报工作！项目承接的进度，需要资金支持！103 GetMediator.Command(this104 105 106 107 108 Console.WriteLine(跑去接项目！109 110 111 112 113 Program 114 115 static Main(String[] args) 116 117 President mediator = new President(); 118 Market market = Market(mediator); 119 Development development = Development(mediator); 120 Financial financial = Financial(mediator); 121 122 mediator.SetFinancial(financial); 123 mediator.SetDevelopment(development); 124 mediator.SetMarket(market); 125 126 market.Process(); 127 market.Apply(); 128 129 Console.Read(); 130 131 132 }
三、中介者模式的实现要点：
将多个对象间复杂的关联关系解耦，Mediator模式将多个对象间的控制逻辑进行集中管理，变“多个对象互相关联”为“多个对象和一个中介者关联”，简化了系统的维护，抵御了可能的变化。随着控制逻辑的复杂化，Mediator具体对象的实现可能相当复杂。这时候可以对Mediator对象进行分解处理。
Facade模式是解耦系统外到系统内（单向）的对相关联关系
Mediator模式是解耦系统内各个对象之间（双向）的关联关系
3.1】、中介者模式的优点
（1）、松散耦合
中介者模式通过把多个同事对象之间的交互封装到中介对象里面，从而使得对象之间松散耦合，基本上可以做到互不依赖。这样一来，同时对象就可以独立的变化和复用，不再“牵一发动全身”
（2）、集中控制交互
多个同事对象的交互，被封装在中介者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改中介者就可以了。
（3）、多对多变为一对多
没有中介者模式的时候，同事对象之间的关系通常是多对多，引入中介者对象后，中介者和同事对象的关系通常变为双向的一对多，这会让对象的关系更容易理解和实现。
3.2】、中介者模式的缺点
（1）、过多集中化
如果同事对象之间的交互非常多，而且比较复杂，当这些复杂性全都集中到中介者的时候，会导致中介者对象变的十分复杂，而且难于维护和管理。
四、.NET 中介者模式的实现
根据我个人的理解，微软的ASP.NET MVC开发模式就是一个中介者模式的很好的实现，其中C就是Controller，也就是中文所说的控制器，控制器就是一个中介者，M和V和它打交道，具体的情况大家可以去查看相关资料，这方面的资料还是很多的。
五、总结
这个模式终于写完了，我们总结一下，为什么要使用中介者模式呢？如果不使用中介者模式的话，各个同事对象将会相互进行引用，如果每个对象都与多个对象进行交互时，将会形成如下图所示的网状结构。
从上图可以发现，如果不使用中介者模式的话，每个对象之间过度耦合，这样的既不利于类的复用也不利于扩展。如果引入了中介者模式，那么对象之间的关系将变成星型结构，采用中介者模式之后会形成如下图所示的结构：
从上图可以发现，使用中介者模式之后，任何一个类的变化，只会影响中介者和类本身，不像之前的设计，任何一个类的变化都会引起其关联所有类的变化。这样的设计大大减少了系统的耦合度。
总结
以上是小编为你收集整理的C#设计模式之十七中介者模式（Mediator Pattern）【行为型】全部内容。
如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。
关于中介模式Mediator和中介模式和代理模式的区别的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于.Net行为型设计模式之中介者模式（Mediator）、23、行为型 - 中介者模式（Mediator）、C#设计模式之Mediator中介者模式解决程序员的七夕缘分问题示例、C#设计模式之十七中介者模式（Mediator Pattern）【行为型】的相关信息，请在本站寻找。
本文标签：
