仅针对特定接口类型（命令）执行 MediatR 预处理器

问题描述 投票：0回答：2

[注意：这是一个“替换”问题。第一个是基于我的主项目的代码，因此我使用来自单一用途项目的代码重新提出了这个问题，该项目更清楚地说明了原理。问题仍然是一样的，只是表述得更好。]

场景

我正在尝试使用 MediatR 管道行为和 Autofac 进行请求路由，在 CQRS 请求管道上设置命令预处理器。我的目标是预处理器仅针对命令 (ICommand<>) 运行，而不是针对所有请求 (IRequest<>) 运行，这将导致预处理器针对命令、查询和事件执行。

问题

我可以让我的 GenericPreProcessor 或任何其他预处理器对所有类型的请求都能正常运行，但是我用来尝试“过滤”注入的任何方法要么返回错误，要么根本不执行所需的预处理处理器。

我在 Autofac 中的针对所有请求的工作管道配置如下所示：

// Pipeline pre/post processors
builder
    .RegisterGeneric(typeof(RequestPostProcessorBehavior<,>))
    .As(typeof(IPipelineBehavior<,>));

builder
    .RegisterGeneric(typeof(RequestPreProcessorBehavior<,>))
    .As(typeof(IPipelineBehavior<,>));

// Works as desired: Fires generic pre-processor for ALL requests, both cmd and query
builder
    .RegisterGeneric(typeof(GenericRequestPreProcessor<>))
    .As(typeof(IRequestPreProcessor<>));

// Works for all requests, but I need a way to limit it to commands
builder
    .RegisterGeneric(typeof(MyCommandPreProcessor<>))
    .As(typeof(IRequestPreProcessor<>));

从概念上讲，我正在尝试做类似的事情，但失败了：

builder
    .RegisterGeneric(typeof(MyCommandPreProcessor<>)) // Note generic
    .As(typeof(IRequestPreProcessor<ICommand<>>));
    // Intellisense error "Unexpected use of an unbound generic"

builder
    .RegisterType(typeof(MyCommandPreProcessor)) // Note non-generic
    .As(typeof(IRequestPreProcessor<ICommand<>>)); 
    // Intellisense error "Unexpected use of an unbound generic"

builder
    .RegisterType(typeof(MyCommandPreProcessor)) // Note non-generic
    .As(typeof(IRequestPreProcessor<ICommand<CommonResult>>)); 
    // No errors, but MyCommandPreProcessor not firing

我正在为 MyCommandPreProcessor 尝试几种不同的配置，一个通用的和一个非通用的，但我被其中一个所困扰：

public class MyCommandPreProcessor<TRequest> : IRequestPreProcessor<TRequest>
{
    public Task Process(TRequest request, CancellationToken cancellationToken)
    {
        Debug.WriteLine("***** MYCOMMAND PREPROCESSOR CALLED *****");
        return Task.CompletedTask;
    }
}

- OR -

public class MyCommandPreProcessor : IRequestPreProcessor<IRequest<ICommonResponse>>
{
    public Task Process(TRequest request, CancellationToken cancellationToken)
    {
        Debug.WriteLine("***** MYCOMMAND PREPROCESSOR CALLED *****");
        return Task.CompletedTask;
    }
}

我的问题

关于如何注册一个预处理器，该预处理器将被限制为仅触发 ICommand<> 封闭类型的 IRequest<> 类型，有什么想法吗？

辅助材料

GitHub 上的项目

可以在 https://github.com/jhoiby/MediatRPreProcessorTest

查看或克隆整个最小示例项目

Autofac MediatR 配置

一个工作配置，带有一个用于所有请求的 GenericRequestPreProcessor。

        builder.RegisterAssemblyTypes(typeof(IMediator).GetTypeInfo().Assembly).AsImplementedInterfaces();

        var mediatrOpenTypes = new[]
        {
            typeof(IRequestHandler<,>),
            typeof(IRequestHandler<>),
            typeof(INotificationHandler<>)
        };

        foreach (var mediatrOpenType in mediatrOpenTypes)
        {
            // Register all command handler in the same assembly as WriteLogMessageCommandHandler
            builder
                .RegisterAssemblyTypes(typeof(MyCommandHandler).GetTypeInfo().Assembly)
                .AsClosedTypesOf(mediatrOpenType)
                .AsImplementedInterfaces();

            // Register all QueryHandlers in the same assembly as GetExternalLoginQueryHandler
            builder
                .RegisterAssemblyTypes(typeof(MyQueryHandler).GetTypeInfo().Assembly)
                .AsClosedTypesOf(mediatrOpenType)
                .AsImplementedInterfaces();
        }

        // Pipeline pre/post processors
        builder.RegisterGeneric(typeof(RequestPostProcessorBehavior<,>)).As(typeof(IPipelineBehavior<,>));
        builder.RegisterGeneric(typeof(RequestPreProcessorBehavior<,>)).As(typeof(IPipelineBehavior<,>));
        builder.RegisterGeneric(typeof(GenericRequestPreProcessor<>)).As(typeof(IRequestPreProcessor<>));
        // builder.RegisterGeneric(typeof(GenericRequestPostProcessor<,>)).As(typeof(IRequestPostProcessor<,>));
        // builder.RegisterGeneric(typeof(GenericPipelineBehavior<,>)).As(typeof(IPipelineBehavior<,>));

        builder.Register<SingleInstanceFactory>(ctx =>
        {
            var c = ctx.Resolve<IComponentContext>();
            return t => c.Resolve(t);
        });

        builder.Register<MultiInstanceFactory>(ctx =>
        {
            var c = ctx.Resolve<IComponentContext>();
            return t => (IEnumerable<object>)c.Resolve(typeof(IEnumerable<>).MakeGenericType(t));
        });

MyCommandPreProcessor 类

我正在尝试这两种方法，通用的和非通用的：

public class MyCommandPreProcessor<TRequest> : IRequestPreProcessor<TRequest>
{
    public Task Process(TRequest request, CancellationToken cancellationToken)
    {
        Debug.WriteLine("***** MYCOMMAND PREPROCESSOR CALLED *****");
        return Task.CompletedTask;
    }
}

- AND -

public class MyCommandPreProcessor : IRequestPreProcessor<IRequest<ICommonResponse>>
{
    public Task Process(TRequest request, CancellationToken cancellationToken)
    {
        Debug.WriteLine("***** MYCOMMAND PREPROCESSOR CALLED *****");
        return Task.CompletedTask;
    }
}

继承结构

// Requests

IMediatR.IRequest<TResponse>
    <- IMessage<TResponse>
        <- ICommand<TResponse>
            <- concrete MyCommand : ICommand<CommonResponse>
        <- IQuery<TResponse>
            <- concrete MyQuery : IQuery<CommonResponse>

// Request Handlers

IMediatR.IRequestHandler<in TRequest,TResponse>
    <- IMessageHandler<in TRequest,TResponse>
        <- ICommandHandler<in TRequest,TResponse> 
            <- concrete MyCommandHandler : ICommandHandler<MyCommand,CommonResponse>
        <- IQueryHandler<In TRequest,TResponse>
            <- concrete MyQueryHandler : IQueryHandler<MyQuery,CommonResponse>

// CommonResponse - A POCO that returns result info

ICommonResponse
    <- concrete CommonResponse

命令

public interface IMessage<TResponse> : MediatR.IRequest<TResponse>
{
}

public interface ICommand<TResponse> : IMessage<TResponse>
{
}

public class MyCommand : ICommand<CommonResponse>
{
}

命令处理程序

public interface IMessageHandler<in TRequest, TResponse> 
    : MediatR.IRequestHandler<TRequest, TResponse> 
        where TRequest : IRequest<TResponse>
{
}

public interface ICommandHandler<in TRequest, TResponse> 
    : IMessageHandler<TRequest, TResponse> 
        where TRequest : IRequest<TResponse>
{
}

public class MyCommandHandler : ICommandHandler<MyCommand, CommonResponse>
{
    public async Task<CommonResponse> Handle(
        MyCommand request, 
        CancellationToken cancellationToken)
    {
        Debug.WriteLine("   ***** Command handler executing *****");

        return
            new CommonResponse(
                succeeded: true,
                data: "Command execution completed successfully.");
    }
}

预处理器注入目标（在 MediatR 管道代码中）

接收注入的IRequestPreProcessor<>的构造函数是：

public RequestPreProcessorBehavior(IEnumerable<IRequestPreProcessor<TRequest>> preProcessors)
    {
        ...
    }

可以在 Github 上查看该文件的第 17 行：

https://github.com/jbogard/MediatR/blob/master/src/MediatR/Pipeline/RequestPreProcessorBehavior.cs

谢谢！

c# generics autofac cqrs mediatr
2个回答
0
投票

我的情况与您完全相同，我相信问题源于 

RequestPreProcessorBehavior<TRequest, TResponse>
没有将所有类型传递给 
IRequestPreProcessor<TRequest>
。

您可以：

  1. 无限制：检查
    every
    中
    request
    中MyCommandPreProcessor<TRequest>的类型：
    

    2. IRequestPreProcessor


创建您自己的预处理行为，公开 
    public Task Process(TRequest request, CancellationToken cancellationToken)
{
    var isCommand = typeof(TRequest).GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(ICommand<>));
    if (isCommand)
    {
        // Magic
    }
}

  1.  的 
    TRequest
    :
    

    2. IPipelineBehavior<TRequest, TResponse>


使用选项 2，您可以向任何为命令/查询特定预处理器实现 
public interface IRequestPreProcessor<in TRequest, TResponse> : IRequestPreProcessor<TRequest>
    where TRequest : IRequest<TResponse>
{
}


public class MyRequestPreProcessorBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IRequest<TResponse>
{
    private readonly IEnumerable<IRequestPreProcessor<TRequest, TResponse>> _preProcessors;

    public RequestPreProcessorBehavior(IEnumerable<IRequestPreProcessor<TRequest, TResponse>> preProcessors)
    {
        _preProcessors = preProcessors;
    }

    public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
    {
        foreach (var processor in _preProcessors)
        {
            await processor.Process(request, cancellationToken).ConfigureAwait(false);
        }

        return await next().ConfigureAwait(false);
    }
}

 的类添加约束。
    





      

      
      
      

      

        

          

            

              
0
投票

              
            

          

        

        


IRequestPreProcessor<TRequest, TResponse>


记住：上面的类中的 GetUserQuery 类没有 IUser 接口。
现在让我们创建预处理器类，该类仅针对标有 IUser 接口的命令/查询执行


public interface IUser{}
public class AddUserCommand: IUser, IRequest<UserModel>{....

public class UpdateUserCommand: IUser, IRequest<UserModel>{....

public class GetUserQuery: IRequest<UserModel>{....



注意：上面的 UserCommandQueryPrepProcessor 类是一个通用类，其中 IUser 仅对继承 IUser 接口的类“AddUserCommand”和“UpdateUserCommand”执行。

    



      

      
    

  

  

    
最新问题


  





  

    © www.soinside.com 2019 - 2024. All rights reserved.