温莎注册单例组件并通过传递构造函数参数进行解析

Question

I have a class with bellow constructor:

Foo(FooType type)

the FooType is an Enum. I register this class like this:

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

I need to have two instances of this class with difference FooType . I Resolve this type like bellow:

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

Are foo1 and foo2 same objects?

Answer is Yes , So, how I can register Foo as singleton and resolve two instance of it with difference FooType ?

Answer 1

I finally resolved my problem by converting IFoo to IFoo<T> and using multiple interface instead of Enum values. Now my code like this:

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

And register and resolve 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

This way resolved my problem, but I am not sure if it is the only way to do this?

Answer 2

You can't do this directly. The singleton lifestyle means there is only one instance of your service, this is what singleton means.

To get multiple instances you can either change the lifestyle to transient (or possibly scoped) or register this service multiple times. To do this, you need a way to distinctly address each service instance.

In Windsor it is possible to register names services.

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

you can then resolve this type by calling:

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

But because your services are singletons, it is not possible to pass the constructor parameter in each resolve, they will only be used once. In this case, it would probably be better set the constructor parameters while registering the services. You can do this by using 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 })
);