In this article, I will try to show how you can extend the Castle Windsor inversion of control container to dynamically select a component based on the current user type. For example, if we were going to develop a web application that is used by B2C (Consumer), B2P (Partner) and B2E (Employee) users. The B2C users have their profile and password in a local database, the B2P users profile can only be accessed via an external third party web service and the B2E users are in an LDAP server.
In this kind of scenario, you would do an interface for a user repository and then an implementation for each user type. This web application serves all these user types from a single instance so the selection of the correct implementation needs to be done at runtime. The solution to that is of course to create a factory that returns the correct implementation based on the current user type. If you have many different scenarios where the implementation will be different based on some common runtime condition, then it would be nice to declare that (for example in an XML configuration file) and then have the inversion of control container dynamically select the correct component. This way you would not need to create a bunch of almost identical factories for each scenario.
Castle Windsor is an inversion of control container that allows you to configure your components and their dependencies in an XML configuration file.
For more information on inversion of control and Castle Windsor: Oren Eini (Ayende) wrote an excellent article on MSDN.
What We Want
In Castle Windsor, you can configure your components by using XML. So it would be good if you could declare the user type a component is meant for in the XML. For example:
ExtendingWindsor" channel="B2E" />
ExtendingWindsor" channel="B2C" />
ExtendingWindsor" channel="B2P" />
The channel attribute in the above XML is not something that exists in the standard Castle Windsor configuration schema. However Castle Windsor allows for additional attributes so the only thing we need to do is to extend the container so that when it searches for an implementation of the
IUserRepository interface, it will choose the correct one.
This is done in the
GetHandler method in the
NamingSubSystem so what we need to do is inherit from the
DefaultNamingSubSystem and override this method.
public override IHandler GetHandler(Type service)
IHandler handlers = base.GetHandlers(service);
if (handlers.Length < 2)
UserPrincipal user = (UserPrincipal) Thread.CurrentPrincipal;
foreach (IHandler handler in handlers)
string channel = handler.ComponentModel.Configuration.Attributes["channel"];
if (channel == user.Channel)
What we need to do now is to replace the default
NamingSubSystem with our own. To do this, we need to look a little at the internals of Castle Windsor and we see that it is actually a wrapper around the Castle MicroKernel container. To exchange the
NamingSubSystem of the underlying kernel in Castle Windsor is a little more problematic than it should be because we can no longer use the nice constructur that just takes in the path to the XML file. We need to use the constructur that takes in an implementation of
This is what we have to do:
IKernel kernel = new DefaultKernel();
kernel.AddSubSystem(SubSystemConstants.NamingKey, new ExtendedNamingSubSystem());
XmlInterpreter interpreter = new XmlInterpreter();
DefaultComponentInstaller installer = new DefaultComponentInstaller();
interpreter.Kernel = kernel;
WindsorContainer container = new WindsorContainer(kernel, installer);
This is set up is a little more complex than what you normally do:
WindsorContainer container = new WindsorContainer(new XmlInterpreter())
But there is no constructor that takes an
IKernel and a
IConfigurationInterpreter. I have thought about submitting such a constructor as a patch to the Castle team but have not gotten around to it.
We Are Done
Now we can do this:
IUserRepository repos = container.Resolve<IUserRepository>();
The container will dynamically select the correct component based on the current principal. This also works if you have a component that has a constructor dependency to the
IUserRepository. You have to think about the lifestyle though so that you do not store a reference to an
IUserRepository implementation in a singleton component.
Instead of extending the
DefaultNamingSubSystem yourself, you can use the
KeySearchNamingSubsystem which is included in the Castle Windsor release. This allows you to use meta data inserted in the component id to do dynamic component selection.
- 2008-04-01 - Initial version