How can I pass an argument down the resolution pipeline in Castle Windsor?

Question

I have an abstract factory (managed by Windsor using .AsFactory()) and one of the components it resolves needs a specific dependency. Normally, this wouldn't be a problem, as Windsor can look at which implementation is registered for that abstraction and supply it. However, there are multiple implementations of that dependency and I want to select one using the same argument as was passed to the top-level factory.

For example:

public interface IAbstractFactory
{
    IComponent Create(int argument);
}

public class MyComponent : IComponent
{
    public MyComponent(IDependency dependency) { }
}

public interface IDependencyFactory
{
    IDependency Create(int argument); // same argument as above
}

I'd like to create the instance of IDependency injected into MyComponent using a Windsor factory with the same argument as was passed into IAbstractFactory. I'd like Windsor to automatically resolve an IDependency using IDependencyFactory and supply it to MyComponent, since I don't want to have to pass the argument into MyComponent when I call it. The specific implementation of IDependency chosen needs to be done based on the same argument passed into IAbstractFactory.Create(argument). This process may need to continue throughout the resolution pipeline, selecting more components using the same argument.

The specific logic to select the implementation will look for the presence of a specific class attribute and attempt to match a value on it, defaulting to Windsor's default selection behavior if it can't be found.

I suspect there's a way to do this using custom handlers or an implementation of ISubDependencyResolver but I'm having trouble fitting the pieces together.

Is there a reasonable way to take care of this just using some of the more advanced registration and component selection features?

Answer 1

Can you explain a bit more about the bigger picture? How do the IComponents or IDependency are being used and by who?

The reason I'm asking for this is as follows:

1. If the mapping between the int argument and the desired IDependency are known to you in advanced, and it maps for a single IDependency then I'd not add a factory and just directly declare this dependency in the installer:

       container.Register(
           Component.For<IDependency>()
               .ImplementedBy<SomeDependency>()
               .Named("SomeDependency"),
           Component.For<IComponent>()
               .ImplementedBy<MyComponent>()
               .DependsOn(Dependency.OnComponent("dependency","SomeDependency")));
   

2. In the case that a specific component might need more then one IDependency to use so I'd change the MyComponent to depend on the IDependencyFactory itself and the IDependency to declare for which int argument it answers. Something along these lines:

   public interface IDependency
   {
       int Argument { get; set; }
   }
   public abstract class DependencyBase : IDependency
   {
       public DependencyBase(int argument) { Argument = argument; }
       public int Argument { get; set; }
   }
   
   public class DependencyA : DependencyBase { public DependencyA() : base(1) {} }
   public class DependencyB : DependencyBase { public DependencyB() : base(2) {} }
   public interface IDependencyFactory
   {
       IDependency Create(int argument);
   }
   
   public interface IComponent { }
   public class MyComponent : IComponent
   {
       public MyComponent(IDependencyFactory dependencyFactory)
       {
           DependencyFactory = dependencyFactory;
       }
   
       public IDependencyFactory DependencyFactory { get; set; }
   }
   public class Installer : IWindsorInstaller
   {
       public void Install(IWindsorContainer container, IConfigurationStore store)
       {
           container.Register(
               Component.For<IDependency>().ImplementedBy<DependencyA>(),
               Component.For<IDependency>().ImplementedBy<DependencyB>(),
               Component.For<IDependencyFactory>().AsFactory(),
               Component.For<IComponent>().ImplementedBy<MyComponent>());
       }
   }
   

   And also implement a ITypedFactoryComoponentSelector that will resolve from the container by the argument intager.

Basically, I'd say you are right about the "Why do I need to implement factories" (or ITypedFactoryComoponentSelector) if you already use the AsFactory - but the TypedFactoryFacility is in its out-of-the-box form for mappings between different object types to different return objects and not different object instances. Maybe read more into the castles documentation about it.

Hope this helps

---

I've changed the IComponent and IDependency classes to have a DoSomething() function just so I can actually execute something.

    public interface IDependency
{
    void DoSomething();
    int Argument { get; set; }
}
public abstract class DependencyBase : IDependency
{
    public DependencyBase(int argument) { Argument = argument; }
    public void DoSomething() { }
    public int Argument { get; set; }
}

Now the MyComponent implementation looks like this:

    public class MyComponent : IComponent
{
    public MyComponent(IDependencyFactory dependencyFactory)
    {
        DependencyFactory = dependencyFactory;
    }

    public void DoSomething(int argument)
    {
        var selectedDependency = DependencyFactory.Create(argument);
        selectedDependency.DoSomething();
    }

    public IDependencyFactory DependencyFactory { get; set; }
}

And I've implemented an ITypedFactoryComponentSelector:

    public class DependencyComponentSelector : ITypedFactoryComponentSelector
{
    public DependencyComponentSelector(IKernel kernel)
    {
        Kernel = kernel;
    }
    public Func<IKernelInternal, IReleasePolicy, object> SelectComponent(MethodInfo method, Type type, object[] arguments)
    {
        return (k, r) =>
        {
            return from dependency in k.ResolveAll<IDependency>()
                   where dependency.Argument == int.Parse(arguments[0].ToString())
                   select dependency;
        };
    }
    public IKernel Kernel { get; set; }
}

(Should obviously add input validation to check that it has been called for the right factory method)

And then in the installer changed the factory's registration to:

Component.For<DependencyComponentSelector>(),
Component.For<IDependencyFactory>().AsFactory(c=> c.SelectedWith<DependencyComponentSelector>()),