Net 6.0 中MediatR的应用「终于解决」

欢迎大家来到IT世界,在知识的湖畔探索吧!

1、前言

MediatR是.NET中的开源简单中介者模式实现，它通过一种进程内消息传递机制（无其他外部依赖），进行请求/响应、命令、查询、通知和事件的消息传递，并通过泛型来支持消息的智能调度， 多用于领域事件中。

2、封装

//扩展 Extensions.cs 用于依赖注入
//如：builder.Services.AddUseMediatR(AppDomain.CurrentDomain.GetAssemblies());
using Microsoft.Extensions.DependencyInjection;
using MediatR;
using System.Reflection;

namespace XmSoft.Core.MediatR;

public static class Extensions
{
    public static void AddUseMediatR(this IServiceCollection services,Assembly assembly)
    {
        services.AddMediatR(assembly);
        services.AddScoped<IMediatRHelper, MediatRHelper>();
    }
}

欢迎大家来到IT世界,在知识的湖畔探索吧!

欢迎大家来到IT世界,在知识的湖畔探索吧!//封装方法：MediatRHelper .cs
using MediatR;
using XmSoft.Core.Results;
using FluentValidation;
using Microsoft.Extensions.DependencyInjection;

namespace XmSoft.Core.MediatR;

public class MediatRHelper : IMediatRHelper
{
    public IMediator mediator;
    public IServiceProvider serviceProvider;
    public MediatRHelper(IMediator _mediator, IServiceProvider _serviceProvider)
    {
        mediator = _mediator;
        serviceProvider = _serviceProvider;
    }
    public async Task<IResult> HandleAsync<TRequest>(TRequest request,bool isValidate = true)
    {
        if (isValidate)
        {
            var validation = Validate(request);

            if (validation.Code != EnumCode.Success) return validation;
        }

        return (await mediator.Send(request)) as IResult;
    }
    public async Task<IResult<TResponse>> HandleAsync<TRequest, TResponse>(TRequest request, bool isValidate = true)
    {
        if (isValidate)
        {
            var validation = Validate(request);

            if (validation.Code != EnumCode.Success) return validation.Fail<TResponse>();

        }

        return (await mediator.Send(request)) as IResult<TResponse>;
    }

    public async Task NotificationAsync<TRequest>(TRequest request)
    {
        await mediator.Publish(request);
    }

    private IResult Validate<TRequest>(TRequest request)
    {
        var validator = serviceProvider.GetService<AbstractValidator<TRequest>>();

        if (validator is null) return Result.Success();

        var validation = validator.Validate(request);

        return validation.IsValid ? Result.Success() : Result.Fail(validation.ToString());
    }
}

3、示例

//创建 OrderRequest.cs
public class OrderRequest: IRequest<IResult>
{
        public string OrderId { get; set; }
        public string OrderName { get; set; }
 }
 
 //创建OrderRequestValidator.cs 校验方法，须引入FluentValidation
 public class OrderRequestValidator : AbstractValidator<OrderRequest>
 {
        public OrderRequestValidator()
        { }
 }
    
//创建OrderNotification.cs
 public class OrderNotification : INotification
 {
        public int OrderId { get; set; }
}

//创建OrderConsumer.cs 实现方式 Request/Response消息方式
public class OrderConsumer : IRequestHandler<OrderRequest, IResult>
{
        public OrderConsumer()
        {

        }
        public Task<IResult> Handle(OrderRequest request, CancellationToken cancellationToken)
        {
            return Task.FromResult(Result.Success());
        }
}

//创建OrderNotificationHandler.cs 方式：广播方式
public class OrderNotificationHandler : INotificationHandler<OrderNotification>
{
    public OrderNotificationHandler()
    {
    }

    public Task Handle(OrderNotification notification, CancellationToken cancellationToken)
    {
        throw new NotImplementedException();
    }
}

欢迎大家来到IT世界,在知识的湖畔探索吧!//Xunit测试示例
public class MediatRTest : IClassFixture<MediatRHelperFixture>
{
        private readonly IMediatRHelper helper;
        public MediatRTest(MediatRHelperFixture fixture)
        {
            helper = fixture.helper;
        }
        /// <summary>
        /// 直播
        /// </summary>
        [Fact]
        public void Test1()
        {
            var request = new OrderRequest
            {
                OrderId = System.Guid.NewGuid().ToString(),
                OrderName = "测试订单",
            };
            var result = helper.HandleAsync(request).GetAwaiter().GetResult();
        }
        /// <summary>
        /// 广播
        /// </summary>
        [Fact]
        public void Notifation()
        {
            var request = new OrderNotification
            {
                OrderId = 122,
            };
             helper.NotificationAsync(request);
        }
    }
    public class MediatRHelperFixture
    {
        public IMediatRHelper helper { get; }

        public MediatRHelperFixture()
        {
            var services = new ServiceCollection();

            services.AddUseMediatR(Assembly.GetExecutingAssembly());
            services.AddScoped<AbstractValidator<OrderRequest>,OrderRequestValidator>();
            helper = services.BuildServiceProvider().GetRequiredService<IMediatRHelper>();
        }
 }