How to configure Castle Windsor to dynamically pick the provider based upon arguments (other than "name") supplied to Resolve()

Question

I am trying to learn how to use Castle Windsor IoC and am having some difficulties understanding how to configure some objects that I need to resolve dynamically. Basically, I have several implementations of IDataSource, and I need to choose the implementation to use based upon how a particular "data source" has been configured. So I might have quite alot of data sources configured to use one of the 3 implementations. My expectation is that the dependant code will take a dependency on a factory method which will give them the correct IDataSource when it is provided with the "data source id" along with the dependencies the data source implementations require (an IPrincipal).

I am struggling with how to correctly write the registration delegate for Windsor. Below is roughly what I've got. I'm trying to use the DynamicParameters method (which may not be the correct thing to use) to perform the logic which figures out which implementation to use and then calling Resolve to pull out that specific version. But I do not know how to return the resolved object, since DynamicParameters is expecting a ComponentReleasingDelegate, which I assume means it should be something like return k => { k.ReleaseComponent(dataSource); }. But then how do I yield the dataSource I've acquired back to the container for it to return to the caller?

struct DataSourceInfo {
  string Id;
  string ProviderType;
}

interface ICatalog : IDictionary<string /* Id */, DataSourceInfo> {
  /* ... */
}

class Catalog : ICatalog {
  /* implement dictionary which looks up DataSourceInfo from their string id */
}

interface IDataSource { /* ... */ }

class Source1 : IDataSource {
  Source1(string id, IPrincipal principal) { /* ... */ }
}

class Source2 : IDataSource {
  Source2(string id, IPrincipal principal) { /* ... */ }
}

/* ... */
/* ... inside Windsor configuration section */
container.Register(Component.For<ICatalog>().LifeStyle.Singleton.ImplementedBy<Catalog>());

// Default service provider is a factory method which uses the string (data source id)
// and looks up the DataSourceInfo from the ICatalog.  It then uses info.ProviderType
// to request IoC to resolve that specific implementation and passes in "id" and "principal"
// to be used to resolve the dependencies of the implementation
container.Register(Component.For<IDataSource>().LifeStyle.Transient
  .DynamicParameters((kernel, context, args) => {
      if (args == null || !args.Contains("id") || !(args["id"] is string)) throw ApplicationException("bad args");

      var id = (string)args["id"];
      var catalog = kernel.Resolve<ICatalog>();
      DataSourceInfo info;
      try { info = catalog[id]; } finally { kernel.ReleaseComponent(catalog); }

      // Now resolve the actual IDataSource
      var dataSource = kernel.Resolve<IDataSource>(info.ProviderType, args);

      // How do I return dataSource???
    });

// Now register the actual implementations
container.Register(Component.For<IDataSource>().LifeStyle.Transient.ImplementedBy<Source1>().Named("Source1"));
container.Register(Component.For<IDataSource>().LifeStyle.Transient.ImplementedBy<Source2>().Named("Source2"));

/* ... */
/* some application startup code which configures some data sources */
class AppConfigurer {
  AppConfigurer(ICatalog catalog) {
    catalog["sourceA"] = new DataSourceInfo() { Id = "sourceA", ProviderType = "Source1" }; // data sourceA is provided by Source1 class
    catalog["sourceB"] = new DataSourceInfo() { Id = "sourceB", ProviderType = "Source2" }; // data sourceB is provided by Source2 class
    catalog["sourceC"] = new DataSourceInfo() { Id = "sourceC", ProviderType = "Source2" }; // data sourceC is provided by Source2 class
    catalog["sourceD"] = new DataSourceInfo() { Id = "sourceD", ProviderType = "Source2" }; // data sourceD is provided by Source2 class
    catalog["sourceE"] = new DataSourceInfo() { Id = "sourceE", ProviderType = "Source1" }; // data sourceE is provided by Source1 class        
  }
}

// Here is where I actually want to use IDataSources, and I do not want to know all the business about IDataSourceInfo.  I just know a dataSourceId and an IPrincipal and want to get an IDataSource to work with.
class Dependant {
  Dependant (Func<string, IPrincipal, IDataSource> factory) {
    var sourceA = factory("sourceA", somePrincipal); // sourceA.GetType() == typeof(Source1)
    var sourceB = factory("sourceB", somePrincipal); // sourceB.GetType() == typeof(Source2)
    var sourceC = factory("sourceC", somePrincipal); // sourceC.GetType() == typeof(Source2)
  }
}

Edit: by switching from DynamicParameters to UsingFactoryMethod I am able to do what I want. But I keep thinking this is wrong because now if I do container.ResolveAll() I'd really like it to skip the factory method but I don't know how to make it do that.

Derek Smith Derek Smith · Accepted Answer · 2011-11-26T16:22:25

Why not just create a custom component type selector and decide which component to load based on that?

Typed Factory Facility - interface-based factories

How to configure Castle Windsor to dynamically pick the provider based upon arguments (other than "name") supplied to Resolve()

1 Answers