中介者模式是一种常见的设计模式,旨再降低程序的耦合性,因为传统的三层模式层层之间需要显示的调用,必须上层依赖下层,耦合性很高,为了解耦,将所有的指令单独放在一个位置处理,其他位置均通过这个位置来间接的调用,从而减少耦合,具体的可以参考中介者模式,建议先了解下DDD里面的事件总线和命令分发。

实现中介者模式有很多方式,例如MediatR就是一种很好用的插件,作者的介绍是这样说的“.NET中的简单中介实现,没有依赖关系的进程内消息传递。通过C#泛型方差支持请求/响应,命令,查询,通知和事件,同步和异步与智能调度。”。这里推荐一款插件Dnspy可以查看dll的源码,这样就可以知道我们所使用的的插件的原理了。

这里先建好一个.Net Core程序,。然后程序入口处注入MeditaR

  services.AddMediatR(typeof(Startup));

 //注册发布订阅中介处理

   services.AddScoped<IMediatorHandler,MediatorHandler>();

   services.AddScoped<IRequestHandler<CreateUserCommand, Unit>, UserCommandHandler>();

对于中介,肯定要先做一个中介处理器,因为程序是面向接口的,所以先定义一个接口,用来表示中介处理器

    /// <summary>
/// 中介处理接口
/// </summary>
public interface IMediatorHandler
{
/// <summary>
/// 发送领域事件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="command"></param>
/// <returns></returns>
Task SendCommand<T>(T command) where T :Command;
}

然后就是它的实现类

    public class MediatorHandler: IMediatorHandler
{
private readonly IMediator _mediator;
public InMemoryBus(IMediator mediator)
{
_mediator = mediator;
}
/// <summary>
/// 发送邻域事件
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="command"></param>
/// <returns></returns>
public Task SendCommand<T>(T command) where T : Command
{
try
{
return _mediator.Send(command);
}
catch (AggregateException ex)
{
throw ex;
}
} }

这里我们用到了IMediator,我们可以根据Dnspy这个工具查看到IMediator 的Send的方法的实现,

// MediatR.Mediator
// Token: 0x06000018 RID: 24 RVA: 0x00002100 File Offset: 0x00000300
public Task<TResponse> Send<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken = default(CancellationToken))
{
if (request == null)
{
throw new ArgumentNullException("request");
}
Type requestType = request.GetType();
return ((RequestHandlerWrapper<TResponse>)Mediator._requestHandlers.GetOrAdd(requestType, (Type t) => Activator.CreateInstance(typeof(RequestHandlerWrapperImpl<, >).MakeGenericType(new Type[]
{
requestType,
typeof(TResponse)
})))).Handle(request, cancellationToken, this._serviceFactory);
}

首先我们看到它的参数IRequest<TResponse> request,所以我们可以知道Task SendCommand<T>(T command),这个方法的T一定是继层自IRequest,所以需要我们写一个基类继层于IRequest

 /// <summary>
/// 领域命令基类
/// </summary>
public class Command:IRequest
{
}
/// <summary>
/// 创建用户领域命令
/// </summary>
public class CreateUserCommand: Command
{
public CreateUserCommand(User user)
{
User = user;
}
public User User { get; private set; }
}

因为项目需要添加功能,好比注册一个用户,所以有一个添加用户的Service代码,然后在构造函数里注入IMediatorHandler

 public class UserService :IUserService
{
private readonly IUserRepository _userRepository;
private readonly IMediatorHandler _mediatorHandler;
public UserService(IUserRepository userRepository, IMediatorHandler mediatorHandler)
{
_userRepository = userRepository;
_mediatorHandler = mediatorHandler;
}
public void Insert(User user)
{
var command = new CreateUserCommand(user);
try
{
Task task = _mediatorHandler.SendCommand(command);
Task.WaitAll(task);
}
catch (AggregateException)
{
throw new FrameworkException("程序内部错误");
}
} }
  public class UserCommandHandler : IRequestHandler<CreateUserCommand, Unit>
{
private readonly IUserRepository _userRepository;
private readonly IMediatorHandler _mediatorHandler;
public UserCommandHandler(IUserRepository userRepository, IMediatorHandler mediatorHandler)
{
_userRepository = userRepository;
_mediatorHandler = mediatorHandler;
}
public Task<Unit> Handle(CreateUserCommand command, CancellationToken cancellationToken)
{ _userRepository.Insert(command.User);
return Task.FromResult(new Unit());
}
}


到这里可以说已经完成了,可以执行了,这样的例子网上也有很多。但是还是需要去了解它的源码,但是自己目前自己只是读懂了源码的20%左右,根据我的理解就是我们在调用IMediator的Send方法时,线程安全集合_requestHandlers会把我们的请求添加到内存里面,具体的就是CreateInstance一个RequestHandlerWrapperImpl对象,但是通过MakeGenericType把它的类型变成了我们请求的类型和返回的类型,然后通过(RequestHandlerWrapper<TResponse>)将Mediator转换类型调用Handler,继续执行RequestHandlerWrapper的实现类RequestHandlerWrapperImpl,然后通过某种方式调用了IRequestHandler,然后找到IRequestHandler的实现类UserCommandHandler,从而完成添加功能。

无奈自己才疏学浅,并没有理解作者的意思。我现在还是有很多疑问。

,以下是我自认为比较重要的的位置了:

1 ,这个类我删了很多代码,只留了我们用的到的 Send方法MediatorHandler类里面用到的

public class Mediator : IMediator
{
// Token: 0x06000017 RID: 23 RVA: 0x000020F1 File Offset: 0x000002F1
public Mediator(ServiceFactory serviceFactory)
{
this._serviceFactory = serviceFactory;
} // Token: 0x06000018 RID: 24 RVA: 0x00002100 File Offset: 0x00000300
public Task<TResponse> Send<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken = default(CancellationToken))
{
if (request == null)
{
throw new ArgumentNullException("request");
}
Type requestType = request.GetType();
return ((RequestHandlerWrapper<TResponse>)Mediator._requestHandlers.GetOrAdd(requestType, (Type t) => Activator.CreateInstance(typeof(RequestHandlerWrapperImpl<, >).MakeGenericType(new Type[]
{
requestType,
typeof(TResponse)
})))).Handle(request, cancellationToken, this._serviceFactory);
}
// Token: 0x04000001 RID: 1
private readonly ServiceFactory _serviceFactory; // Token: 0x04000002 RID: 2
private static readonly ConcurrentDictionary<Type, object> _requestHandlers = new ConcurrentDictionary<Type, object>(); }

2,

public interface IPipelineBehavior<in TRequest, TResponse>
{
// Token: 0x0600000C RID: 12
Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next);
}

3

 internal abstract class RequestHandlerWrapper<TResponse> : RequestHandlerBase
{
public abstract Task<TResponse> Handle(IRequest<TResponse> request, CancellationToken cancellationToken,
ServiceFactory serviceFactory);
} internal class RequestHandlerWrapperImpl<TRequest, TResponse> : RequestHandlerWrapper<TResponse>
where TRequest : IRequest<TResponse>
{
public override Task<TResponse> Handle(IRequest<TResponse> request, CancellationToken cancellationToken,
ServiceFactory serviceFactory)
{
Task<TResponse> Handler() => GetHandler<IRequestHandler<TRequest, TResponse>>(serviceFactory).Handle((TRequest) request, cancellationToken); return serviceFactory
.GetInstances<IPipelineBehavior<TRequest, TResponse>>()
.Reverse()
.Aggregate((RequestHandlerDelegate<TResponse>) Handler, (next, pipeline) => () => pipeline.Handle((TRequest)request, cancellationToken, next))();
}
}

4,

public abstract class RequestHandler<TRequest> : IRequestHandler<TRequest>, IRequestHandler<TRequest, Unit> where TRequest : IRequest
{
// Token: 0x06000014 RID: 20 RVA: 0x000020DB File Offset: 0x000002DB
Task<Unit> IRequestHandler<TRequest, Unit>.Handle(TRequest request, CancellationToken cancellationToken)
{
this.Handle(request);
return Unit.Task;
} // Token: 0x06000015 RID: 21
protected abstract void Handle(TRequest request);
}

4

一起来学习.net core程序使用中介者模式:MediatR插件的更多相关文章

  1. MediatR一个.net中简单好用的中介者模式实现方案

    MediatRGit地址:https://github.com/jbogard/MediatR 1.安装妞盖特包 一般来说只需要安装一个MediatR就行了,.net core程序需要再安装一个Med ...

  2. .NET CORE学习笔记系列(4)——ASP.NET CORE 程序启用SSL

    一.什么是SSL? 1.概念: SSL(Secure Sockets Layer 安全套接层),及其继任者传输层安全(Transport Layer Security,TLS)是为网络通信提供安全及数 ...

  3. 在 ASP.NET Core 项目中使用 MediatR 实现中介者模式

    一.前言  最近有在看 DDD 的相关资料以及微软的 eShopOnContainers 这个项目中基于 DDD 的架构设计,在 Ordering 这个示例服务中,可以看到各层之间的代码调用与我们之前 ...

  4. 将Windows系统编译的.NET Core程序发布到Ubuntu系统

    在可移植方面.NET Core应用程序分为两种,Portable application(便捷,需要目标机器安装.NET Core Runtime)和Self-contained applicatio ...

  5. 从头认识一下docker-附带asp.net core程序的docker化部署

    从头认识一下docker-附带asp.net core程序的docker化部署 简介 在计算机技术日新月异的今天, Docker 在国内发展的如火如荼,特别是在一线互联网公司, Docker 的使用是 ...

  6. 使用Dapper.Contrib 开发.net core程序,兼容多种数据库

    关于Dapper的介绍,我想很多人都对它有一定的了解,这个类似一个轻型的ORM框架是目前应用非常火的一个东西,据说各方面的性能都不错,而且可以支持多种数据库,在开始介绍这个文章之前,我花了不少功夫来学 ...

  7. [译]ASP.NET Core中使用MediatR实现命令和中介者模式

    作者:依乐祝 原文地址:https://www.cnblogs.com/yilezhu/p/9866068.html 在本文中,我将解释命令模式,以及如何利用基于命令模式的第三方库来实现它们,以及如何 ...

  8. [转帖]以Windows服务方式运行ASP.NET Core程序

    以Windows服务方式运行ASP.NET Core程序 原作者blog: https://www.cnblogs.com/guogangj/p/9198031.htmlaspnet的blog 需要持 ...

  9. 创建.NET Core程序的Nuget Package

    最近在看ASP.NET Core MVC的教材,几乎每章开始都要重复从Empty project开始创建一个ASP.NET Core的项目,然后手动修改project.json,增加经典三目录(Mod ...

随机推荐

  1. 用jTessBoxEditorFX训练字库

    软件下载:https://sourceforge.net/projects/vietocr/files/jTessBoxEditor/ 官方字库下载:https://github.com/tesser ...

  2. OpenSSL生成私钥和公钥

    1.生成私钥 -- 生成 RSA 私钥(传统格式的) openssl genrsa -out rsa_private_key.pem 1024 -- 将传统格式的私钥转换成 PKCS#8 格式的(JA ...

  3. Python 和 R 中的一数多图

    R # 一数多图 x <- 2:6 y <- 7:3 y1 <- y +2 opar <- par(no.readonly = TRUE) par(mfrow=c(2, 3)) ...

  4. 【转】Pandas学习笔记(七)plot画图

    Pandas学习笔记系列: Pandas学习笔记(一)基本介绍 Pandas学习笔记(二)选择数据 Pandas学习笔记(三)修改&添加值 Pandas学习笔记(四)处理丢失值 Pandas学 ...

  5. HDU6583:Typewriter(dp+后缀自动机)

    传送门 题意: 给出\(p,q\),现在要你生成一个字符串\(s\). 你可以进行两种操作:一种是花费\(p\)的代价随意在后面添加一个字符,另一种是花费\(q\)的代价可以随意赋值前面的一个子串. ...

  6. 09-C#笔记-循环

    1. while 同 C++ 2. for 同 C++ 3. foreach,注意数组的定义 int[] fibarray = new int[] { 0, 1, 1, 2, 3, 5, 8, 13 ...

  7. 重新学习Spring注解——servlet3.0

    53.servlet3.0-简介&测试 54.servlet3.0-ServletContainerInitializer 55.servlet3.0-ServletContext注册三大组件 ...

  8. mybatis框架-resultMap的自动映射级别-partial 和full的探讨

    现在我们做一个小实验,输出一下上一个案例中没有匹配的属性,注意哦,现在user类中是有内部嵌套的复杂数据类型的 运行结果: 注意到:现在居然连userPassword都打印不出来了,原因就是user类 ...

  9. 开始Golang之旅了

  10. 学习:VB之4C法

    前言:4C法对于单纯的本地验证的话应该比较好使,但是基于网络验证可能就不是很好用了,尽管到了第二个窗口,功能应该还是不能用 逆向过程: 1.直接载入OD,发现第一条汇编指令如下 0040120C &g ...