Dependency injection ion将首先出现，否则将选择最后一次注册，但它将根据自身进行循环。@Steven我已经检查过了，我的行为似乎正在按预期进行（至少在我调试应用程序时是如此）。我主要遵循这里提到的>>啊，我明白了，管道行为不是装饰器。我完全不同意这一点：“这是一种更自然的方式

---

ion将首先出现，否则将选择最后一次注册，但它将根据自身进行循环。@Steven我已经检查过了，我的行为似乎正在按预期进行（至少在我调试应用程序时是如此）。我主要遵循这里提到的>>啊，我明白了，管道行为不是装饰器。我完全不同意这一点：“这是一种更自然的方式来增强处理程序的行为”，这是真的“在容器中得到更好的支持”，但这不是一个不做“正确的事情”的错误论点。我假设

LoggingBehavior

和

ValidationBehavior

都是装饰程序。您试图注册（

ipipepelinebehavior

）装饰器的方式，但是通过将它们堆叠起来的方式，对.NET核心容器不起作用。NET核心不支持装饰程序。如果存在非通用注册，则该注册将首先出现，否则将选择最后一个注册，但它将根据自身进行循环。@Steven我已经检查过，并且我的行为似乎正在按预期工作（至少在调试我的应用程序时是如此）。我主要遵循这里提到的>>啊，我明白了，管道行为不是装饰器。我完全不同意这一点：“这是一种更自然的方式来提高你的处理者的行为”，这是真的“在容器中得到更好的支持”，但这是一个不好的论点，因为没有做“正确的事情”。嗨。答案是后来的事。那是什么时候@Kiksen我发现您可以像下面这样注册每个处理器

container.register（Component.For（typeof（IRequestPostProcessor））.ImplementedBy（）你好。答案是后来的事。那是什么时候@Kiksen我发现您可以像下面这样注册每个处理器
container.register（Component.For（typeof（IRequestPostProcessor））.ImplementedBy（）
public class IdentifyUserTypeCommandHandler : IRequestPreProcessor<RegisterUserCommand>
{
    private readonly IOptions<TecApiOptions> _options;

    public IdentifyUserTypeCommandHandler(IOptions<TecApiOptions> options)
    {
        _options = options;
    }

    public async Task Process(RegisterUserCommand request)
    {
        request.Type = "internal";
        await Task.FromResult(true);
    }
}

        // Pipeline engine used internally to simplify controllers
        services.AddMediatR();
        // Pre-processors
        services.AddTransient(typeof(IRequestPreProcessor<RegisterUserCommand>), typeof(IdentifyUserTypeCommandHandler));

        // Registers command validator
        services.AddTransient(typeof(IValidator<RegisterUserCommand>), typeof(RegisterUserCommandValidator));

        // Registers generic behaviors
        services.AddTransient(typeof(IPipelineBehavior<,>), typeof(Pipeline<,>));
        services.AddTransient(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));
        services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
        services.AddTransient(typeof(IPipelineBehavior<,>), typeof(RequestPreProcessorBehavior<,>));

public class LoggingBehavior<TCommand, TResponse> : IPipelineBehavior<TCommand, TResponse>
{
    private readonly ILogger _logger;

    public LoggingBehavior(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory?.CreateLogger(typeof(TCommand).Name) ?? throw new ArgumentNullException(nameof(loggerFactory));
    }

    public async Task<TResponse> Handle(TCommand request, RequestHandlerDelegate<TResponse> next)
    {
        try
        {
            _logger.LogInformation(LoggingEvents.RUN_HANDLER, $"Handling '{typeof(TCommand).Name}'");
            var response = await next();
            _logger.LogInformation(LoggingEvents.RUN_HANDLER, $"Handled '{typeof(TResponse).Name}'");
            return response;
        }
        catch (Exception e)
        {
            _logger.LogError(
                LoggingEvents.RUN_HANDLER_EXCEPTION, e,
                $"An error occured while processing pipeline '{GetType().Name}' [{typeof(TCommand).Name} >> {typeof(TResponse).Name}]");
            throw;
        }
    }
}

public class GenericRequestPostProcessor<TRequest, TResponse> : IRequestPostProcessor<TRequest, TResponse>

public class GenericRequestPreProcessor<TRequest> : IRequestPreProcessor<TRequest>

services.AddTransient(typeof(IPipelineBehavior<,>), typeof(RequestPreProcessorBehavior<,>));
services.AddMediatR();

public class PingDecorator<TRequest> : IRequestPreProcessor<TRequest>
{
    public Task Process(TRequest request)
    {
        return Unit.Task;
    }
}

public class PingDecorator<TRequest> : IRequestPreProcessor<TRequest> where TRequest:Ping
{
    public Task Process(TRequest request)
    {
        request.Message = request.Message + " Decorated";
        return Unit.Task;
    }
}