c# Simple Injector 仅从一个客户端在一个类中注入装饰器

Question

大家好，
我有一个问题，我有一个这样的界面：

public interface ICommand<in TRequest, out TResponse> 
    where TRequest : class
    where TResponse : BaseResponse
{
    TResponse Execute(TRequest request);
}

然后我两个类实现这个接口是这样的：

public class ExternalAddUser : ICommand<ExternalAddUserRequest, ExternalAddUserResponse>
{
    private readonly ICommand<AddUserRequest, AddUserResponse> _command;

    public ExternalAddUser(ICommand<AddUserRequest, AddUserResponse> command)
    {
        _command = command;
    }

    public ExternalAddUserResponse Execute(ExternalAddUserRequest request)
    {
        var response = _command.Execute(Mapper.Map<AddUserRequest>(request));

        return Mapper.Map<ExternalAddUserResponse>(response);
    }
}

还有这个：

public class AddUser : ICommand<AddUserRequest, AddUserResponse>
{
    private readonly IUnitOfWork _unitOfWork;
    private readonly IMessageService _messageService;
    private readonly IDefaultSettings _settings;
    private readonly IMessageFactory _messageFactory;

    public AddUser(IUnitOfWork unitOfWork, IMessageService messageService, IDefaultSettings settings, IMessageFactory messageFactory)
    {
        _unitOfWork = unitOfWork;
        _messageService = messageService;
        _settings = settings;
        _messageFactory = messageFactory;
    }

    public AddUserResponse Execute(AddUserRequest request)
    {
        // My implementation here
    }
}

Interface IMessageFactory 是一个“工厂/模板”模式，它创建一个只有以下属性的 IMessage 接口：Body、Subject、Language。 我已经用这样的简单注射器注册了我的课程：

container.Register(typeof(ICommand<,>), businessLayerAssembly);   
container.Register<IDefaultSettings, DefaultSettings>(Lifestyle.Singleton);
container.Register<ISecuritySettings, SecuritySettings>(Lifestyle.Singleton);
container.RegisterConditional<IMessageFactory, ActivationMessageFactory>
            (c => c.Consumer.ImplementationType == typeof(AddUser) 
                  || c.Consumer.ImplementationType == typeof(SendActivationEmail));
container.RegisterConditional<IMessageFactory, RecoveryMessageFactory>
            (c => !c.Handled);

现在我有另一个类是 ActivationMessageFactory 的装饰器，如下所示：

public class ActivationMessageWithoutLinkFactory : IMessageFactory 
{
    private readonly IMessageFactory _messageFactory;

    public ActivationMessageWithoutLinkFactory(IMessageFactory messageFactory)
    {
         _messageFactory = messageFactory;
    }

    public IMessage CreateMessage(MessageData messageData)
    {
        // Implementation
    }
}

我的问题是：
当从 ExternalAddUser 类调用此类时，是否可以在 AddUser 类中注入 ActivationMessageWithoutLinkFactory 装饰器？ 气味代码示例：

public class ExternalAddUser : ICommand<ExternalAddUserRequest, ExternalAddUserResponse>
{
    public ExternalAddUserResponse Execute(ExternalAddUserRequest request)
    {

        ICommand<AddUserRequest, AddUserResponse> command = new AddUser(new SqlUnitOfWork(), new EmailService(), 
            new DefaultSettings(), new ActivationMessageWithoutLinkFactory(new ActivationMessageFactory()));
    }
}

这是我要构建的对象图：

// AddUser injected into ExternalAddUser
new ExternalAddUser(
    new AddUser(
        new UnitOfWork(),
        new MessageService(),
        new DefaultSettings(),
        new ActivationMessageWithoutLinkFactory(
            new ActivationMessageFactory())))

// AddUser injected into anything else
new AnythingElse(
    new AddUser(
        new UnitOfWork(),
        new MessageService(),
        new DefaultSettings(),
        new ActivationMessageFactory())) // no decorator

谢谢你的回答，希望我清楚。

Answer 1

您要实现的是基于消费者的消费者应用装饰器。这在 Simple Injector 中不容易实现。相反，您可以尝试以下方法：与其使装饰器成为条件，不如将其注入可以在请求开始时设置的上下文数据。这样装饰器可以决定是否执行其逻辑，或者它应该简单地将调用转发给它的被装饰者。

更新：

您可以定义以下抽象：

public class ICommandContext
{
    Type RootRequest { get; }
}

此抽象允许您检查当前正在运行的根请求的类型。你可以在你的装饰器中使用这个抽象：

public class ActivationMessageWithoutLinkFactory : IMessageFactory 
{
    private readonly ICommandContext _context;
    private readonly IMessageFactory _messageFactory;

    public ActivationMessageWithoutLinkFactory(
        ICommandContext context,
        IMessageFactory messageFactory)
    {
        _context = context;
        _messageFactory = messageFactory;
    }

    public IMessage CreateMessage(MessageData messageData)
    {
        if (_context.RootRequest == typeof(ExternalAddUser))
        {
            // Begin decorated stuff
            var message = _messageFactory.CreateMessage(messageData);
            // End decorated stuff

            return message;
        }
        else
        {
            return _messageFactory.CreateMessage(messageData);
        }
    }
}

在您的 Composition Root 中，您现在可以创建一个 ICommandContext 实现和一个可以管理此上下文的 ICommand<,> 装饰器：

public class CommandContext : ICommandContext
{
    public Stack<Type> Requests = new Stack<Type>();

    public Type RootRequest => Requests.First();
}

public class ContextCommandDecorator<TRequest, TResponse> : ICommand<TRequest, TResponse>
{
    private readonly CommandContext _context;
    private readonly ICommand<TRequest, TResponse> _decoratee;
    public ContextCommandDecorator(
        CommandContext context,
        ICommand<TRequest, TResponse> decoratee)
    {
        _context = context;
        _decoratee = decoratee;
    }

    public TResponse Execute(TRequest request)
    {
        _context.Push(typeof(TRequest));

        try
        {
            return _decoratee.Execute(request);
        }
        finally
        {
            _context.Pop();
        }
    }
}

最后，您可以将以下三个注册添加到您的应用程序中：

container.Register<ICommandContext, CommandContext>(Lifestyle.Scoped);
container.Register<CommandContext>(Lifestyle.Scoped);

container.RegisterDecorator(typeof(ICommand<,>), typeof(ContextCommandDecorator<,>));