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