C# 4.0 使用继承解析Castle中的泛型构造函数参数&；没有接口

虽然我以前在温莎城堡使用过泛型，但这种特殊的组合目前让我感到困惑

我想将其解析为构造函数参数，在这个单元测试中，通过显式调用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);
    }

公共抽象类BaseSettings，其中T:class
{
受保护的无效保存（T obj）
{ }
}
公共类附加设置：基本设置
{ }
公共类其他设置：基本设置
{ }
公共类LogConfig，其中T:class
{
专用只读BaseSettings\u客户端；
公共日志配置（基本设置客户端）
{
_客户=客户；
}
公共基本设置客户端
{
获取{return\u client；}
}
}
[测试]
公共无效解析_泛型（）
{
var container=新的WindsorContainer（）；
container.Register（Component.For（））；
var otherSettings=container.Resolve（）；
Assert.That（其他设置为.Not.Null）；
}

您可以尝试以下方法：

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

container.Register(
组件。对于（typeof（LogConfig）），
Component.For（）.ImplementedBy（））；

祝你好运， Marwijn.

您可以尝试以下方法：

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

container.Register(
组件。对于（typeof（LogConfig）），
Component.For（）.ImplementedBy（））；

祝你好运，

---

Marwijn.

首先，需要像@Marwijn那样注册一个开放的泛型类型

LogConfig

然后，您可以通过选择并使用

BasedOn（typeof（BaseSettings））

和

with service.Base（）注册所有
BaseSettings
实现

以下试验方法证明了这一点：

[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>();
}

[TestMethod]
公共无效解析_泛型（）
{
//安排
var container=新的WindsorContainer（）；
集装箱。登记(
组件。对于（typeof（LogConfig）），
Classes.FromThisAssembly（）.BasedOn（typeof（BaseSettings））.WithService.Base（）；
//表演
var otherSettings=container.Resolve（）；
var addinSettings=container.Resolve首先，需要像@Marwijn那样注册一个打开的泛型类型
LogConfig

然后，您可以通过选择并使用
BasedOn（typeof（BaseSettings））
和
with service.Base（）注册所有
BaseSettings
实现

以下试验方法证明了这一点：

[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>();
}

[TestMethod]
公共无效解析_泛型（）
{
//安排
var container=新的WindsorContainer（）；
集装箱。登记(
组件。对于（typeof（LogConfig）），
Classes.FromThisAssembly（）.BasedOn（typeof（BaseSettings））.WithService.Base（）；
//表演
var otherSettings=container.Resolve（）；
var addinSettings=container.ResolveGood improvement。谢谢，我不知道基于开放泛型的工作原理。太棒了，是的，这就是我需要改进的地方。谢谢，我不知道基于开放泛型的工作原理。太棒了，是的，这就是我需要的