C# 在温莎城堡，一个组件可以拥有它吗'；s生命周期绑定到一个组件，而该组件不是它的直接依赖项？

给定一组具有以下依赖结构的对象（使用构造函数注入）：

IWidget依赖于IWidgetDependency依赖于IDependencyConfiguration

即使我想在多个地方使用相同的IWidgetDependency实现，是否可以设置IDependencyConfiguration实现的生命周期，以便将它们绑定到特定的IWidget实现

这是代码；它将正确解析FooWidget，但无法解析BarWidget，我不明白为什么：

var container = new WindsorContainer();

container.Register(Component.For<FooWidget>(), Component.For<BarWidget>());

container.Register(Component.For<IWidgetDependency>().ImplementedBy<WidgetDependency>().LifestyleTransient());

container.Register(
    Component.For<IDependencyConfiguration>().ImplementedBy<FooConfiguration>().LifestyleBoundTo<FooWidget>(),
    Component.For<IDependencyConfiguration>().ImplementedBy<BarConfiguration>().LifestyleBoundTo<BarWidget>());

// I expect to resolve a FooWidget that contains a WidgetDependency that contains a FooConfiguration
var fooWidget = container.Resolve<FooWidget>(); // Works fine

// I expect to resolve a BarWidget that contains a WidgetDependency that contains a BarConfiguration
var barWidget = container.Resolve<BarWidget>(); // Scope was not available for 'FooConfiguration'

var容器=新的WindsorContainer（）；
container.Register（Component.For（），Component.For（））；
container.Register（Component.For（）.ImplementedBy（）.LifestyleTransient（））；
集装箱。登记(
Component.For（）.ImplementedBy（）.LifestyleBoundTo（），
Component.For（）.ImplementedBy（）.LifestyleBoundTo（））；
//我希望解析一个包含WidgetDependency的FooWidget，该WidgetDependency包含一个FooConfiguration
var fooWidget=container.Resolve（）；//很好
//我希望解析包含WidgetDependency的BarWidget，该WidgetDependency包含BarConfiguration
var barWidget=container.Resolve（）；//“FooConfiguration”的作用域不可用

我认为生活方式不是这样的。束缚生活方式仅仅意味着一个组成部分（孩子）的生活方式与另一个组成部分（父母）的生活方式绑定，它对依赖解决没有影响

我不知道有什么简单的方法可以实现您想要的，我的第一反应是查看

DependsOn

功能，但它是现成的，它只能将依赖项绑定到目标组件，而不能绑定到目标其他依赖项

在使用工厂方法解析嵌套依赖项时，我确实找到了一种方法来检查根组件中的

DependsOn

依赖项。它适用于您的场景，但不是特别可重用的

var container = new WindsorContainer();

container.Register(
    Component.For<IDependencyConfiguration>().LifestyleTransient()
             .UsingFactoryMethod(ResolveRootDependency<IDependencyConfiguration>));

container.Register(
    Component.For<FooConfiguration>().LifestyleTransient(),
    Component.For<BarConfiguration>().LifestyleTransient());

container.Register(
    Component.For<FooWidget>().DependsOn(Dependency.OnComponent<IDependencyConfiguration, FooConfiguration>()),
    Component.For<BarWidget>().DependsOn(Dependency.OnComponent<IDependencyConfiguration, BarConfiguration>()));

container.Register(Component.For<IWidgetDependency>().ImplementedBy<WidgetDependency>().LifestyleTransient());

// I expect to resolve a FooWidget that contains a WidgetDependency that contains a FooConfiguration
var fooWidget = container.Resolve<FooWidget>(); // Works fine

// I expect to resolve a BarWidget that contains a WidgetDependency that contains a BarConfiguration
var barWidget = container.Resolve<BarWidget>(); // Works fine

---

您能否共享FooWidget、BarWidget和WidgetDependency的构造函数/公共属性？

private static TDependencyType ResolveRootDependency<TDependencyType>(IKernel kernel, CreationContext context)
{
    foreach (var dependency in context.Handler.ComponentModel.Dependencies)
    {
        if (dependency.DependencyKey == typeof(TDependencyType).AssemblyQualifiedName)
        {
            return kernel.Resolve<TDependencyType>(dependency.ReferencedComponentName);
        }
    }

    return kernel.Resolve<TDependencyType>();
}