Question

我正在试图弄清楚如何使用Castle Windsor注册以下装饰器场景。我有以下界面：

public interface ICalculate<T> where T : class 
{
   void Calculate(T value);
}

以及最后一个是装饰器的几个实现。

public class FooCalculator : ICalculate<Foo> 
{
   public void Calculate(Foo value)
   {
       // do something here with the value..
   }
}

public class BarCalculator : ICalculate<Bar>
{
    public void Calculate(Bar value)
    {
       // do something else here....
    }
}

public class CalculatorDecorator<T> : ICalculate<T> where T : class
{
    private readonly ICalculate<T> _calculator;

    public CalculatorDecorator(ICalculate<T> calculator)
    {
         _calculator = calculator;
    }

    public void Calculate(T value)
    {
       // do for example some logging...
       _calculator.Calculate(value);
    }
}

这是我的注册码

container.Register(Classes.FromAssembly()
                          .BasedOn(typeof(ICalculate<>))
                          .WithService.Base());

当我通过其通用接口请求其中一个实现时，我希望Windsor使用在构造函数中注入的请求实现来解析CalculatorDecorator。

// I would like calculator to be CalculatorDecorator<Foo> in 
// this case but it is FooCalculator.
var calculator = container.Resolve<ICalculate<Foo>>();

// The same goes for this one...
var calculator = containr.Resolve<ICalculate<Bar>>();

提前致谢！

编辑：

如果我喜欢这个，那就有用了

container.Register(Component.For<ICalculate<Foo>>()
                            .ImplementedBy<CalculatorDecorator<Foo>>(),
                   Component.For<ICalculate<Foo>>()
                            .ImplementedBy<FooCalculator>());

container.Register(Component.For<ICalculate<Bar>>()
                            .ImplementedBy<CalculatorDecorator<Bar>>(),
                   Component.For<ICalculate<Bar>>()
                            .ImplementedBy<BarCalculator>());

但如果可能的话，我更愿意注册所有组件。

Answer 1

container.Register(AllTypes.FromAssembly()
                      .BasedOn(typeof(ICalculate<>))
                      .WithService.Base());

你尝试过这个吗？我们有类似的情况，这对我们有用。

<强>更新

我不认为这是可能的，因为你会创建一个循环依赖。我的确如下：

注册

 var container = new WindsorContainer();


        container.Register(Component.For(typeof(IDecorator<>)).ImplementedBy(typeof(CalculatorDecorator<>)));

        container.Register(AllTypes.FromThisAssembly()
                               .BasedOn(typeof (ICalculate<>))
                               .WithService.Base());



        var fc = container.Resolve<IDecorator<Foo>>();
        var bc = container.Resolve<IDecorator<Bar>>();

接口：

   public interface ICalculate<T> where T : class
{
    void Calculate(T value);
}

public interface IDecorator<T> : ICalculate<T> where T : class
{

}

实现：

public class FooCalculator : ICalculate<Foo>
{
    public void Calculate(Foo value)
    {
        // do something here with the value..
    }
}

public class BarCalculator : ICalculate<Bar>
{
    public void Calculate(Bar value)
    {
        // do something else here....
    }
}

public class CalculatorDecorator<T>: IDecorator<T> where T : class
{
    private readonly ICalculate<T> _calculator;

    public CalculatorDecorator(ICalculate<T> calculator)
    {
        _calculator = calculator;
    }

    public void Calculate(T value)
    {
        // do for example some logging...
        _calculator.Calculate(value);
    }
}

与温莎的通用装饰

1 个答案: