我该如何在温莎城堡注册？

Question

public interface IDo
{
    ... details 
}
public class DoOneThing : IDo
{
    ...
}
public class DoAnotherThing : IDo
{
    ....
}

public interface IFooService
{
    ... details
}

public class FooService
{
    private IDo do;

    public FooService(IDo do)
    {
        // instance is of type specifically resolved per call
        this.do = do;
    }


    ...
}

Container.Register(ComponentFor<IDo>().ImplementedBy<DoOneThing>().Named("DoOneThing");
Container.Register(ComponentFor<IFooService>().ImplementedBy<FooService>().DependsOn(Dependency.OnComponent(typeof(IDo), "DoOneThing")).Named("DoItWithOneThing");
Container.Register(ComponentFor<IFooService>().ImplementedBy<FooService>().DependsOn(Dependency.OnComponent(typeof(IDo), "DoAnotherThing")).Named("DoItWithAnotherThing");



Container.Resolve<IFooService>("DoItWithOneThing");

How Do I register FooService to have a dependency of type IDo and then resolve with a specific implementation type? I've tried using something like the code above but I get an exception that no component for service can be found. If I try to resolve to the named instance then it tells me that it's waiting for dependencies of DoOneThing.

Answer 1

You can use the typed Dependency.OnComponent as mentioned in Castle Windsor - multiple implementation of an interface .

See also: Castle Project -- Inline dependencies

var container = new WindsorContainer();

container.Register(
    Component
        .For<IDo>()
        .ImplementedBy<DoAnotherThing>());

container.Register(
    Component
        .For<IDo>()
        .ImplementedBy<DoOneThing>());

container.Register(
    Component
        .For<IFooService>()
        .ImplementedBy<FooService>()
        .Named("DoItWithOneThing")
        .DependsOn(
            Dependency.OnComponent<IDo, DoOneThing>()));

container.Register(
    Component
        .For<IFooService>()
        .ImplementedBy<FooService>()
        .Named("DoItWithAnotherThing")
        .DependsOn(
            Dependency.OnComponent<IDo, DoAnotherThing>()));

Test

var doItWithOneThing = container.Resolve<IFooService>("DoItWithOneThing");
var doItWithAnotherThing = container.Resolve<IFooService>("DoItWithAnotherThing");

Console
    .WriteLine(
        "doItWithOneThing.Do is DoOneThing // {0}",
        doItWithOneThing.Do is DoOneThing);
Console
    .WriteLine(
        "doItWithAnotherThing.Do is DoAnotherThing // {0}",
        doItWithAnotherThing.Do is DoAnotherThing);

Output

doItWithOneThing.Do is DoOneThing // True
doItWithAnotherThing.Do is DoAnotherThing // True

Declarations

public interface IDo {}
public class DoOneThing : IDo {}
public class DoAnotherThing : IDo {}
public interface IFooService
{
    IDo Do { get; }
}

public class FooService : IFooService
{
    public FooService(IDo @do)
    {
        Do = @do;
    }

    public IDo Do { get; private set; }
}