温莎城堡：强制解析器使用指定的构造函数

Question

示例如下：

interface IComponentA {};

class ComponentA : IComponentA { };

interface IComponentB { };

class ComponentB : IComponentB { };

interface IComponentC { };

class ComponentC : IComponentC
{
    public ComponentC(IComponentA a)
    {
        Console.WriteLine("Constructor A"); 
    }

    public ComponentC(IComponentB b) 
    {
        Console.WriteLine("Constructor B");
    }
};

所有这些组件都在 Castle Windsor 容器中注册。

但是 ComponentC 类有 2 个重载的构造函数。当 ComponentC 被激活时，可以使用它们中的任何一个。

我需要使用 ComponentC(IComponentB b) 构造函数。

有一段时间，我正在使用UsingFactoryMethod()方法来解决这个问题：

container
    .Register(Component
        .For<IComponentA>()
        .ImplementedBy<ComponentA>())
    .Register(Component
        .For<IComponentB>()
        .ImplementedBy<ComponentB>())
    .Register(Component
        .For<IComponentC>()
        .UsingFactoryMethod(() => new ComponentC(
            container.Resolve<IComponentB>())));

它有效，但温莎城堡可能提供了一些更好的方法来做到这一点？

非常感谢任何帮助。

谢谢。

Answer 1

Windsor 不提供对这种情况的支持，因为它打破了它（以及大多数容器）运行所基于的不成文假设之一：“所有构造函数都是平等创建的”。

这意味着，无论选择哪个构造函数，组件的行为都不应该有功能差异。在所有条件相同的情况下，组件的依赖项越多，它拥有的功能就越多，这就是为什么 Windsor 会倾向于首先选择更贪婪的构造函数，但如果像你这样，我会说发生了两种情况之一：

• 你的组件实际上可能是两个组件伪装成一个。在这种情况下，您可能会想要拆分它。
• 您的组件实际上确实使用它所具有的两个依赖项进行操作，因此它应该有一个接受它们的构造函数。

我见过的另一种情况是这样的：

public class Foo
{
   public Foo(ISession session){/*code*/}
   public Foo(ISessionFactory factory):this(factory.OpenSession()){}
}

虽然这乍一看似乎是一个聪明的主意，但充其量它是多余的、令人困惑的和不必要的。如果您的情况类似于此，我只需删除第二个构造函数。

Answer 2

嗯，这很糟糕，但有一种方法（过去我不得不使用 Linq2Sql DataContext 对象来做到这一点）。您创建一个装饰器类并注册它。

假设你有这个接口：

public interface IService 
{
    void DoSomething();
}

并且你有一个如下的实现：

public class Service : IService
{
    private readonly ILogger _logger;

    public Service(ILogger logger)
        : this(logger, SomeDefaultListOfThings())
    {
    }

    // Let's say Windsor is calling this ctor for some reason (ArrayResolver?)
    public Service(ILogger logger, IEnumerable<object> emptyArrayFromWindsor)
    {
        _logger = logger;
        PutTheItemsSomewhere(emptyArrayFromWindsor);
    }

    public void DoSomething()
    {
        // Something that relies on the list of items...
    }
}

但正如示例所示，由于某种原因，Windsor 调用了错误的 ctor，否则你无法说服它（正如 Krzysztof 正确指出的那样）。然后，您可以按如下方式创建装饰器类，该类只有一个构造函数，从而消除了歧义：

public class SpecificCtorServiceDecorator : IService
{
    private readonly IService _decorated;

    public SpecificCtorServiceDecorator(ILogger logger)
    {
        _decorated = new Service(logger);
    }

    public void DoSomething()
    {
        _decorated.DoSomething();
    }
}

然后您可以注册该类：

container.Register(
    Component.For<IService>()
             .ImplementedBy<SpecificCtorServiceDecorator>());

当然，最好不要使用这种奇怪的默认值-在其他构造函数中发生的事情（搜索对于“穷人的依赖注入”），但在您无法控制您真正想要的类的情况下（就像我在 Linq2Sql 中一样，或者如果它这将是对 API 的重大更改），那么这可能会让您摆脱麻烦。