Configure Unity container per-request in OWIN middleware

Question

I'm wanting to configure registrations in a Unity container being used by ASP.NET Web API 2 based on properties of a HTTP request. For example, a request to /api/database1/values should result in a Unity container configuration with an IDbContext configured for database1, while a request to /api/database4/values will get an IDbContext configured for database4.

I've gotten so far as using UnityHierarchicalDependencyResolver as the dependency resolver, so types registered with HierarchicalLifetimeManager last only for the lifetime of the request. This works well for getting types resolved per request. But how to get them registered per request using OWIN middleware is beyond me.

In my middleware, a call to System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver.GetService(typeof(IUnityContainer)) gets an instance of IUnityContainer, but it's the same container for all requests, including any registrations from previous requests.

By encapsulating UnityHierarchicalDependencyResolver with my own implementation of IDependencyResolver I can see that IDependencyResolver.BeginScope isn't called until much later in the process. So the problem would seem to be that the child container isn't created until Web API wakes up, long after my middleware calls Next(..).

Is there a way I can get the scope of my dependency resolver to start sooner? Is there some other strategy that I'm missing. In case it makes any difference, I'm hosting in IIS, but favouring the OWIN middleware approach.

Update

This isn't an answer, and it's too big for a comment, but after struggling to solve this with Unity I decided to switch to Autofac and it all just fell into place.

The Autofac OWIN packages (Autofac.Mvc5.Owin, Autofac.Owin, Autofac.WebApi2.Owin) make it dead easy to use Autofac within the OWIN pipeline and ensure appropriate lifetime management in ASP.NET MVC and Web API. This was the missing link.

I couldn't find a way to reconfigure the container per-request, but it did at least make it possible to configure a factory per-request (so yes, @Haukinger and @alltej, you were right to push in that direction.

So I register a factory like:

builder.RegisterType<DataDependencyFactory>().InstancePerRequest();

And register the create method of that factory like:

builder
  .Register(c => c.Resolve<DataDependencyFactory>().CreateDataDependency())
  .As<IDataDependency>()
  .InstancePerRequest();

Registering the factory this way is particularly useful, because downstream dependents don't need to be aware of the factory. I like this because my dependents don't need a factory, they need an instance. The container bends to the needs of my dependents, not the other way around :)

Then, in a piece of OWIN middleware, I resolve the factory, and set a property on it according to the properties of the request. Subsequent resolution of IDataDependency in an MVC or Web API controller, or anything else later in the OWIN pipeline, will get an instance configured according to the property on the factory.

Answer 1

Based on your api URL ("/api/database4/values"), I suggest that you create a filter attribute(e.g. DbIdFilter) so that you can reuse the filter attribute to other controller methods that follow similar url path/segment like this below:

[HttpGet]
[DbIdFilter]
[Route("{databaseId}/values")]
public IHttpActionResult GetValues()
{
    return Ok();
}


[HttpGet]
[DbIdFilter]
[Route("{databaseId}/products")]
public IHttpActionResult GetProducts()
{
    return Ok();
}

First, create the filter attribute:

public class DbIdFilterAttribute : ActionFilterAttribute
{
    private readonly string _routeDataId;
    private const string defaultRouteName = "databaseId";
    public DbIdFilterAttribute():this(defaultRouteName)
    {}

    public DbIdFilterAttribute(string routeDataId)
    {
        _routeDataId = routeDataId;
    }

    public override void OnActionExecuting(HttpActionContext actionContext)
    {

        var routeData = actionContext.Request.GetRouteData();

        var dbId = routeData.Values[_routeDataId] as string;

        //here we create the db instance at the filter level.

        DbInstanceFactory.RegisterDbInstance(dbId);


    }

}

Next, create an instance factory that will register/resolve the db instance during runtime:

public class DbInstanceFactory : IDbInstanceFactory
{
    public static IDbInstance RegisterDbInstance(string databaseId)
    {
        var factory = UnityConfig.GetConfiguredContainer().Resolve<IDbInstanceFactory>();
        return factory.CreateInstance(databaseId);
    }

    public IDbInstance CreateInstance(string databaseId)
    {
        var container = UnityConfig.GetConfiguredContainer();
        //container.RegisterType<IDbInstance, DbInstance>();

        container.RegisterType<IDbInstance, DbInstance>(new InjectionConstructor(databaseId));
        var dbInstance = container.Resolve<IDbInstance>();
        return dbInstance;
    }

    public IDbInstance GetInstance()
    {
        var container = UnityConfig.GetConfiguredContainer();
        var dbInstance = container.Resolve<IDbInstance>();
        return dbInstance;
    }
}

public interface IDbInstanceFactory
{
    IDbInstance CreateInstance(string databaseId);
    IDbInstance GetInstance();
}

Register this factory class in UnityConfig.cs (or wherever you currently register the types):

container.RegisterType<IDbInstanceFactory, DbInstanceFactory>
    (new ContainerControlledLifetimeManager());

It's registered ContainerControlledLifetimeManager since this factory does not have to be a per request.

So just a basic DbInstance class below(for clarity) that takes a parameter in the constructor (this parameter can be your connection string or a named connection):

public class DbInstance : IDbInstance
{
    public string DbId { get; }

    public DbInstance(string databaseId)
    {
        DbId = databaseId;
    }
}

public interface IDbInstance
{
    string DbId { get; }
}

In controller class, you can use it like this:

....
private IDbInstanceFactory _dbFactory;

public MyController(IDbInstanceFactory dbFactory)
{
    _dbFactory = dbFactory;
}

// Alternate, if you want to use property injection instead of constructor injection
//[Dependency]
//public IDbInstanceFactory DbFactory { get; set; }

[HttpGet]
[DbIdFilter]
[Route("{databaseId}/test")]
public IHttpActionResult Test()
{
    var db = _dbFactory.GetInstance();

    return Ok(db.DbId);
}

...