开源地址

Github：https://github.com/jbogard/MediatR (opens new window)

MediatR 是一个轻量级的开源库，为 .NET 开发人员提供了一种简单的方式来实现基于中介者模式的应用程序设计。该库的主要目标是使开发人员能够编写易于维护和可扩展的应用程序。在本文中，我们将深入介绍 MediatR 的用途、功能和使用。

MediatR 的用途

在很多应用程序中，我们需要处理一些复杂的逻辑，这些逻辑可能涉及多个对象之间的交互。传统的做法是将这些逻辑分散在应用程序的各个部分，导致代码复杂度增加，难以维护和扩展。MediatR 提供了一种优雅的解决方案，将这些逻辑集中在一个地方，使代码更加简洁和可读。

MediatR 的核心概念

在深入介绍 MediatR 的使用之前，我们需要了解一些核心概念。

IRequest<TResponse>

IRequest 是一个泛型接口，表示一个请求，通常情况下，我们需要为 IRequest 定义一个泛型类型参数，表示该请求的响应类型。例如：

public class GetOrderByIdQuery : IRequest<Order>
{
    public int OrderId { get; set; }
}

IRequestHandler<TRequest, TResponse>

IRequestHandler 是一个泛型接口，用于处理 IRequest。它包含一个 Handle 方法，该方法接受一个 IRequest 对象，并返回一个泛型类型参数 TResponse。例如：

public class GetOrderByIdQueryHandler : IRequestHandler<GetOrderByIdQuery, Order>
{
    public async Task<Order> Handle(GetOrderByIdQuery request, CancellationToken cancellationToken)
    {
        // 实现获取订单的逻辑
    }
}

Mediator

Mediator 是一个中介者类，它负责将 IRequest 对象发送到 IRequestHandler，获取响应并返回。它也提供了一些方法来支持处理多个 IRequest 的批处理操作。

2种模式比较说明

中文说明	模式	发起者	消费者	返回值
俗称:命令Command	只可以一对一	mediator.Send	实现接口IRequestHandler	可以有返回值,也可以没有返回值
俗称:事件Event	可以一对多	mediator.Publish	实现接口INotificationHandler	没有返回值

MediatR 的使用

我们已经了解了 MediatR 的核心概念，现在让我们看看如何在 .NET 应用程序中使用它。

安装 MediatR

要使用 MediatR，我们需要首先将其添加到项目中。我们可以使用 NuGet 包管理器或通过命令行安装 MediatR。

通过 NuGet 包管理器安装 MediatR：

Install-Package MediatR

通过命令行安装 MediatR：

dotnet add package MediatR

注册服务

我们需要在应用程序的服务容器中注册 MediatR。可以在 Startup.cs 文件的 ConfigureServices 方法中完成注册：

public void ConfigureServices(IServiceCollection services)
{
    services.AddMediatR(typeof(Startup));
}

定义请求和处理程序

接下来，我们需要定义 IRequest 和 IRequestHandler：

public class GetOrderByIdQuery : IRequest<Order>
{
    public int OrderId { get; set; }
}

public class GetOrderByIdQueryHandler : IRequestHandler<GetOrderByIdQuery, Order>
{
    public async Task<Order> Handle(GetOrderByIdQuery request, CancellationToken cancellationToken)
    {
        // 实现获取订单的逻辑
    }
}

​```csharp

### 发送请求

现在，我们已经定义了 GetOrderByIdQuery 和 GetOrderByIdQueryHandler，我们可以使用 Mediator 来发送请求：

​```csharp
public class OrdersController : ControllerBase
{
    private readonly IMediator _mediator;

    public OrdersController(IMediator mediator)
    {
        _mediator = mediator;
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<Order>> GetOrderById(int id)
    {
        var query = new GetOrderByIdQuery { OrderId = id };
        var order = await _mediator.Send(query);
        return order;
    }
}

在上面的代码中，我们注入了 IMediator 接口，然后创建了 GetOrderByIdQuery 对象并将其发送到 Mediator 中。Mediator 将请求传递给 GetOrderByIdQueryHandler 处理程序，并返回 Order 对象。

处理多个请求

MediatR 也支持处理多个 IRequest，我们可以使用 Send 方法的批处理重载来处理多个请求：

public async Task<ActionResult<List<Order>>> GetOrdersByIds(int[] ids)
{
    var queries = ids.Select(id => new GetOrderByIdQuery { OrderId = id }).ToList();
    var orders = await _mediator.Send(queries);
    return orders;
}

在上面的代码中，我们使用 Select 方法创建了一个包含 GetOrderByIdQuery 对象的列表，然后将其传递给 Mediator 的 Send 方法。

发布通知

除了 IRequest 和 IRequestHandler，MediatR 还提供了 INotification 和 INotificationHandler 接口，用于实现发布/订阅模式中的通知机制。

我们可以使用 Publish 方法来发布通知：

public class OrderCreatedNotification : INotification
{
    public int OrderId { get; set; }
}

public class OrderCreatedNotificationHandler : INotificationHandler<OrderCreatedNotification>
{
    public async Task Handle(OrderCreatedNotification notification, CancellationToken cancellationToken)
    {
        // 实现处理订单创建通知的逻辑
    }
}

public class OrdersController : ControllerBase
{
    private readonly IMediator _mediator;

    public OrdersController(IMediator mediator)
    {
        _mediator = mediator;
    }

    [HttpPost]
    public async Task<ActionResult> CreateOrder(Order order)
    {
        // 实现创建订单的逻辑

        var notification = new OrderCreatedNotification { OrderId = order.Id };
        await _mediator.Publish(notification);

        return Ok();
    }
}

在上面的代码中，我们定义了 OrderCreatedNotification 和 OrderCreatedNotificationHandler，然后在 OrdersController 中发布了 OrderCreatedNotification。

命令模式使用

1.有返回值

1.定义传递模型

继承接口IRequest

模型一般用XXXCommand命名

    //定义模型
    //实现IRequest,返回布尔值
public record CreateCustomerCommand (
        string FirstName , string LastName ) : IRequest<bool>;

2.实现消费者

实现接口IRequestHandler

一般用xxxHandler命名

    /*
    消费者,实现接口IRequestHandler <>中第1个传递参数的类型,第2个是返回数据类型
    */

    public class CreateCustomerCommandHandler : IRequestHandler<CreateCustomerCommand , bool>
    {
        private readonly ILogger<CreateCustomerCommandHandler> _logger;

        public CreateCustomerCommandHandler ( ILogger<CreateCustomerCommandHandler> logger )
        {
            _logger = logger;
        }

        public Task<bool> Handle ( CreateCustomerCommand request , CancellationToken cancellationToken )
        {
            //request就是传递过来的数据
            this._logger.LogInformation( "FirstName:" + request.FirstName );
            this._logger.LogInformation( "LastName:" + request.LastName );
                      
            return Task.FromResult( true );
        }
    }

3.生产者(发送请求)

CreateCustomerCommand createCustomerCommand = new CreateCustomerCommand( "q" , "h" );

bool result = await this.mediator.Send( createCustomerCommand );

2.无返回值

1.定义传递模型

    //定义模型
    //实现IRequest, 这种无返回值

public record CreatePingCommand (
    string FirstName , string LastName ) : IRequest;

2.实现消息者

    /*
消费者,实现接口IRequestHandler <>中第1个传递参数的类型 ,这种无返回值
*/

    public class CreatePingCommandHandler : IRequestHandler<CreatePingCommand>
    {
        private readonly ILogger<CreatePingCommandHandler> _logger;

        public CreatePingCommandHandler ( ILogger<CreatePingCommandHandler> logger )
        {
            _logger = logger;
        }

        public Task Handle ( CreatePingCommand request , CancellationToken cancellationToken )
        {
            //request就是传递过来的数据
            this._logger.LogInformation( "FirstName:" + request.FirstName );
            this._logger.LogInformation( "LastName:" + request.LastName );

            return Task.CompletedTask;
        }
    }

3.生产者(发送请求)

CreatePingCommand _Command = new CreatePingCommand( "q" , "hmz" );

// 没有返回值
await this.mediator.Send( _Command );

消息模式使用

1.定义传递模型

继承接口INotification

模型一般用XXXEvent命名

//继承接口,消息传递类

public record CustomerCreatedEvent (
        string FirstName , string LastName , DateTime RegistrationDate ) : INotification;

2.实现消费者

因为是一对多的,所以可以定义多个消费者

实现接口INotificationHandler

一般用xxxHandler命名

第1个消费者

    /*
消费者,实现接口INotificationHandler <>中第1个传递参数的类型 
*/

    public class CustomerCreatedEmailSenderHandler : INotificationHandler<CustomerCreatedEvent>
    {
        private readonly ILogger<CustomerCreatedEmailSenderHandler> _logger;

        public CustomerCreatedEmailSenderHandler ( ILogger<CustomerCreatedEmailSenderHandler> logger )
        {
            _logger = logger;
        }

        public Task Handle ( CustomerCreatedEvent notification , CancellationToken cancellationToken )
        {
            //notification就是传递过来的数据
            this._logger.LogInformation( "CustomerCreatedEmailSenderHandler FirstName:" + notification.FirstName );
            this._logger.LogInformation( "CustomerCreatedEmailSenderHandler LastName:" + notification.LastName );
                       

            return Task.CompletedTask;
        }
    }

第2个消费者

    public class CustomerCreatedLoggerHandler : INotificationHandler<CustomerCreatedEvent>
    {
        private readonly ILogger<CustomerCreatedLoggerHandler> _logger;

        public CustomerCreatedLoggerHandler ( ILogger<CustomerCreatedLoggerHandler> logger )
        {
            _logger = logger;
        }

        public Task Handle ( CustomerCreatedEvent notification , CancellationToken cancellationToken )
        {
            //notification就是传递过来的数据
            this._logger.LogInformation( "CustomerCreatedLoggerHandler FirstName:" + notification.FirstName );
            this._logger.LogInformation( "CustomerCreatedLoggerHandler LastName:" + notification.LastName );

            return Task.CompletedTask;
        }
    }

3.生产者(发送请求)

CustomerCreatedEvent _Command = new CustomerCreatedEvent( "q" , "hmz" , DateTime.Now );

//  Publish发布消息
await this.mediator.Publish( _Command );

处理异常

MediatR 还提供了异常处理的机制。我们可以实现 IRequestExceptionHandler<TRequest, TResponse> 接口来处理异常：

public class GetOrderByIdQueryExceptionHandler : IRequestExceptionHandler<GetOrderByIdQuery, Order, Exception>
{
    public Task Handle(GetOrderByIdQuery request, Exception exception, RequestExceptionHandlerState<Order> state, CancellationToken cancellationToken)
    {
        // 实现异常处理逻辑

        return Task.CompletedTask;
    }
}

​```csharp

在上面的代码中，我们实现了 GetOrderByIdQueryExceptionHandler，该处理程序负责处理 GetOrderByIdQuery 的异常。如果 Mediator 在处理 GetOrderByIdQuery 请求时遇到异常，将调用 GetOrderByIdQueryExceptionHandler 处理程序。

要注册异常处理程序，请在 Startup.cs 文件的 ConfigureServices 方法中添加以下代码：

​```csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddMediatR(typeof(Startup), typeof(GetOrderByIdQueryExceptionHandler));
}

在上面的代码中，我们将 GetOrderByIdQueryExceptionHandler 添加到服务容器中。

配置 MediatR

我们可以使用 MediatR 的配置选项来修改其默认行为。可以在 Startup.cs 文件的 ConfigureServices 方法中添加以下代码：

public void ConfigureServices(IServiceCollection services)
{
    services.AddMediatR(typeof(Startup), options =>
    {
        options.AsScoped(); // 配置作用域
        options.WithPipelineBehavior(typeof(LoggingBehavior<>)); // 配置管道行为
    });
}

在上面的代码中，我们使用 AsScoped 方法将 Mediator 配置为作用域服务，并使用 WithPipelineBehavior 方法添加 LoggingBehavior 管道行为。

总结

MediatR 是一个非常有用的库，它提供了一种简单的方式来实现基于中介者模式的应用程序设计。在本文中，我们了解了 MediatR 的核心概念和用法，以及如何使用它来发送请求、处理多个请求、发布通知和处理异常。希望这篇文章对你有所帮助！