Question

有时当我使用依赖注入时（这里以Ninject为例），我们需要使用仅在运行时可用的参数来构造依赖项。

这是abstract factory pattern有用的地方，我理解其中的大部分内容。

但是有没有理由为什么我们应该/不应该直接将工厂生产的价值注入消费者呢？

以下是一个示例，假设Foo只能由运行时string参数构建，而IFooFactory是构建Foo的接口：

将抽象工厂注入消费者

public class ConsumerService : IConsumerService
{
     private readonly IFooFactory _fooFactory;
     private readonly string _param;

     public Consumer(IFooFactory fooFactory, string param)
     {
         _fooFactory = fooFactory;
         _param = param;
     }

     public void PerformAction()
     {
         Foo foo = _fooFactory.Construct(_param);
         // Additional processing of foo
     }
}

public interface IFooFactory
{
    Foo Construct(string param);
}

public class MyNinjectModule : NinjectModule
{
    public override void Load()
    {
        Bind<IConsumerService>()
            .To<ConsumerService>()
            .WithConstructorArgument("param", /* Some run time param */);
        Bind<IFooFactory>().To<FooFactory>();
    }
}

依靠Ninject 直接将IFooFactory构建的值注入Consumer

public class Consumer
{
     private readonly Foo _foo;

     public Consumer(Foo foo)
     {
         _foo = foo;
     }

     public void PerformAction()
     {
         // Additional processing of foo
     }
}

public interface IFooFactory
{
    Foo Construct(string param);
}

public class MyNinjectModule : NinjectModule
{
    public override void Load()
    {
        Bind<IConsumerService>()
            .To<ConsumerService>()
            .WithConstructorArgument("foo", 
                                     ctx => ctx.Kernel
                                               .Get<IFooFactory>()
                                               .Construct(/* Some run time param */);
    }
}

我应该赞成其他人吗？

我应该将抽象工厂或抽象工厂生成的值注入到使用者中

0 个答案: