0

虽然我之前在 Castle Windsor 中使用过泛型,但这种特殊的组合目前让我感到困惑。

我想将其解析为构造函数参数,在此单元测试中通过显式调用resolve() 对其进行模拟。

但我无法弄清楚我需要做什么注册和解析的组合。我在下面显示了测试失败的代码,以明确问题。

    public abstract class BaseSettings<T> where T : class
    {
        protected void Save(T obj)
        { }
    }

    public class AddinSettings : BaseSettings<AddinSettings>
    { }

    public class OtherSettings : BaseSettings<OtherSettings>
    { }

    public class LogConfig<T> where T : class
    {
        private readonly BaseSettings<T> _client;

        public LogConfig(BaseSettings<T> client)
        {
            _client = client;
        }

        public BaseSettings<T> Client
        {
            get { return _client; }
        }
    }

    [Test]
    public void resolve_generics()
    {
        var container = new WindsorContainer();
        container.Register(Component.For<OtherSettings >());
        var otherSettings = container.Resolve<LogConfig<OtherSettings>>();
        Assert.That(otherSettings, Is.Not.Null);
    }
4

2 回答 2

3

首先,需要LogConfig<>像@Marwijn 那样注册一个开放的泛型类型。

然后,您可以通过使用和为组件选择基本类型/条件服务来注册所有BaseSettings<T>实现。BasedOn(typeof(BaseSettings<>))WithService.Base()

下面的测试方法证明了这一点:

[TestMethod]
public void resolve_generics()
{
    // arrange
    var container = new WindsorContainer();
    container.Register(
        Component.For(typeof(LogConfig<>)),
        Classes.FromThisAssembly().BasedOn(typeof(BaseSettings<>)).WithService.Base());

    //act
    var otherSettings = container.Resolve<LogConfig<OtherSettings>>();
    var addinSettings = container.Resolve<LogConfig<AddinSettings>>();

    // assert
    otherSettings.Should().NotBeNull();
    otherSettings.Client.Should().BeOfType<OtherSettings>();

    addinSettings.Should().NotBeNull();
    addinSettings.Client.Should().BeOfType<AddinSettings>();
}

关于基于基类注册类型的类似问题还有另一个答案。

于 2014-01-20T22:52:57.510 回答
0

你可以试试这个:

container.Register(
    Component.For(typeof(LogConfig<>)),
    Component.For<BaseSettings<OtherSettings>>().ImplementedBy<OtherSettings>());

祝你好运,马尔维恩。

于 2014-01-20T08:13:33.513 回答