使用 Castle Windsor 在服务类的构造函数中使用参数化构造函数初始化类

提供运行时、用户驱动或其他动态依赖项的一种主要方法*是使用工厂来创建您的对象。Castle Windsor 提供了几种不同的工具来帮助解决这个问题，或者您可以使用内核并自己实现一个工厂。

Windsor 的工具允许您提供基于委托的工厂，这些工厂只是用于创建对象的方法。您可以在这里使用它，但是您在创建的内容方面失去了一些灵活性（如果您要将 的实现替换为ICalculator其他类，则必须更新此方法）。

为了获得最大的灵活性，您需要使用 Windsor 的基于接口的工厂。有了这些，您提供了一个工厂的接口，然后 Windsor 将自动生成它的实现。

让我们以上面代码的简化版本为例。如果您刚刚拥有此对象：

public class Calculator : ICalculator
{
    string Operator;

    public Calculator(string operator)
    {
        Operator=operator;
    }
}

并且您想operator在创建对象时传入，您可以像这样定义一个工厂：

public interface ICalculatorFactory
{
    ICalculator Create(string operator);
}

然后你会在你的安装程序中注册它：

kernel.Register(Component.For<ICalulatorFactory>().AsFactory());

现在，在任何你想使用计算器的地方，你都可以为它注入一个工厂，然后调用Create：

public class CalculatorUseExample
{
    private readonly ICalculator addCalculator;
    private readonly ICalculator subCalculator;

    public CalculatorUseExample(ICalculatorFactory calculatorFactory)
    {
        addCalculator = calculatorFactory.Create("+");
        subCalculator = calculatorFactory.Create("-");
    }
}

请注意，operator参数的名称很重要；默认情况下（您可以根据需要更改此设置），Windsor 按名称匹配参数。

如果我们将您的CalculatorService类重新添加到组合中，您可以使用相同的模式：

public interface ICalculatorServiceFactory
{
    ICalculatorService Create(string operator);
}

public class CalculatorService : ICalculatorService
{
    private readonly ICalculator Calculator;

    public CalculatorService(string operator, ICalculatorFactory calculatorFactory)
    {
        Calculator=calculatorFactory.Create(operator);   
    }
}

但我真的不喜欢那样，因为服务为什么要关心运营商是什么？这是计算器的一个细节。相反，将工厂更改为只接受一个ICalculator并将对象组合在一起创建此服务：

public interface ICalculatorServiceFactory
{
    ICalculatorService Create(ICalculator calculator);
}

public class CalculatorService : ICalculatorService
{
    private readonly ICalculator Calculator;

    public CalculatorService(ICalculator calculator)
    {
        Calculator=calculator;
    }
}

public class CalculatorServiceUseExample
{
    public CalculatorServiceUseExample(ICalculatorServiceFactory calculatorServiceFactory, ICalculatorFactory calculatorFactory)
    {
        var addCalculator = calculatorFactory.Create("+");
        var service = calculatorServiceFactory.Create(addCalculator);

        // TODO: use the service
    }
}

使用这种模式有优点也有缺点，我在这里的回答中详细介绍了这些。一些优点是您可以保护自己免受未来更改的影响并避免服务定位器模式。缺点包括接口对象的激增和工厂的潜在病毒式使用（请参阅上面我必须创建另一个工厂的第一个解决方案）。

* 当然还有其他的，这只是我解决这种特殊情况的方式，因为对我来说，它表明了意图，并且是代码读者最容易发现的。

根据您对 WCF 的编辑以及我了解您正在尝试做的事情，我会像这样实施服务合同：

public class CalculatorService : ICalculatorService
{
    private readonly ICalculatorFactory calculatorFactory;
    private ICalculator calculator;

    public CalculatorService(ICalculatorFactory calculatorFactory)
    {
        // store the factory until we need it
        this.calculatorFactory = calculatorFactory;
    }

    public void ChangeCalculatorServiceClient(string operator)
    {
        // A new operator, we'll need a new calculator
        calculator = calculatorFactory.Create(operator);
    }
}

好吧，你又改变了你的问题，包括另一个皱纹；现在您想根据参数实例化不同的类型。您可以并且仍然应该为此使用工厂，这就是我的做法：

using Castle.Facilities.TypedFactory;

public class WindsorInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(
            Component.For<IGreeting, Greeting>(),
            Component.For<IGreetingFactory>().AsFactory(),
            Component.For<IGreetingService, GreetingService>(),
            Component.For<ILanguageFactory, LanguageFactory>());
    }
}

public interface ILanguageFactory
{
    ILanguage Create(string language);
}

public class LanguageFactory : ILanguageFactory
{
    private readonly IKernel kernel;

    public LanguageFactory(IKernel kernel)
    {
        this.kernel = kernel;
    }

    public ILanguage Create(string language)
    {
        switch (language)
        {
            case "S":
                return kernel.Resolve<Spanish>();
            default:
                throw new ArgumentException();
        }
    }
}

public class GreetingService : IGreetingService
{
    private readonly IGreetingFactory greetingFactory;
    private readonly ILanguageFactory languageFactory;
    private IGreeting greeting;

    public GreetingService(IGreetingFactory greetingFactory, ILanguageFactory languageFactory)
    {
        // store the factory until we need it
        this.greetingFactory = greetingFactory;
    }

    public string SayHello (string strLanguage)
    {
        var language = languageFactory.Create(strLanguage);
        greeting = greetingFactory.Create(language);
        return greeting.SayHello();
    }
}