一起来学习.net core程序使用中介者模式:MediatR插件

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