Question

我有一个带有bellow构造函数的类：

Foo(FooType type)

FooType是一个枚举。我这样注册这个类：

container.Register(
  Component.For<IFoo>()
           .ImplementedBy<Foo>()
           .LifestyleSingleton())

我需要有两个此类的实例，区别为FooType。我解决这种类型如下：

IFoo foo1 = container.Resolve<IFoo>(new { type = FooType.Type1 });
IFoo foo2 = container.Resolve<IFoo>(new { type = FooType.Type2 });

foo1和foo2是否有相同的对象？

答案是是，那么，我如何将Foo注册为单身并解决其中两个不同FooType的实例？

Answer 1

我终于通过将IFoo转换为IFoo<T>并使用多个接口而不是Enum值来解决我的问题。现在我的代码是这样的：

public interface IFooType
{ }

public interface IFooType1 : IFooType
{ }

public interface IFooType2 : IFooType
{ }

public interface IFoo<T>
    where T : IFooType
{
    string FooType { get; }
}

public class Foo<T> : IFoo<T>
    where T : IFooType
{
    public string FooType
    {
        get
        {
            return typeof(T).ToString();
        }
    }
}

注册并解决Foo：

container.Register(Component.For(typeof(IFoo<>))
                            .ImplementedBy(typeof(Foo<>))
                            .LifestyleSingleton());

var foo1 = container.Resolve<IFoo<IFooType1>>();
var foo2 = container.Resolve<IFoo<IFooType2>>();

Console.WriteLine("foo1 : " + foo1.FooType); // return foo1: IFooType1
Console.WriteLine("foo2 : " + foo2.FooType); // return foo1: IFooType2

这样解决了我的问题，但我不确定这是否是唯一的方法呢？

Answer 2

你不能直接这样做。单身生活方式意味着只有一个服务实例，这就是单身人士的意思。

要获得多个实例，您可以将生活方式更改为瞬态（或可能是作用域）或多次注册此服务。要做到这一点，您需要一种明确地解决每个服务实例的方法。

在Windsor中，可以注册名称服务。

container.Register(
    Component.For<IFoo>().ImplementedBy<Foo>().LifestyleSingleton().Named("Instance1),
    Component.For<IFoo>().ImplementedBy<Foo>().LifestyleSingleton().Named("Instance2)
);

然后您可以通过调用：

来解决此类型

var intsance1 = container.Resolve("Instance1");
var intsance2 = container.Resolve("Instance2");

但是因为你的服务是单例，所以不可能在每个解析中传递构造函数参数，它们只会被使用一次。在这种情况下，在注册服务时可能更好地设置构造函数参数。您可以使用DepensOn(...)

执行此操作

container.Register(
    Component.For<IFoo>()
             .ImplementedBy<Foo>()
             .LifestyleSingleton()
             .Named("Instance1)
             .DependsOn(new { type = FooType.Type1 }),
    Component.For<IFoo>()
             .ImplementedBy<Foo>()
             .LifestyleSingleton()
             .Named("Instance2)
             .DependsOn(new { type = FooType.Type2 })
);

Windsor通过传递构造函数参数来注册singleton组件和Resolve

2 个答案: