标签：core 插件 Task Handle MediatR cancellationToken serviceFactory request public
中介者模式是一种常见的设计模式，旨再降低程序的耦合性，因为传统的三层模式层层之间需要显示的调用，必须上层依赖下层，耦合性很高，为了解耦，将所有的指令单独放在一个位置处理，其他位置均通过这个位置来间接的调用，从而减少耦合，具体的可以参考中介者模式，建议先了解下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
标签：core,插件,Task,Handle,MediatR,cancellationToken,serviceFactory,request,public 来源： https://www.cnblogs.com/MrHanBlog/p/11309336.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。