How to register Drum.UriMaker<> using Simple Injector?

Question

I'm using Drum which provides a generic class `UriMaker:

public class UriMaker<TController>
{
    // I need use this one
    public UriMaker(UriMakerContext context, HttpRequestMessage request) { }

    public UriMaker(Func<MethodInfo, RouteEntry> mapper, UrlHelper urlHelper) { }
}

Used like this:

public class UserController : ApiController
{
    public UserController(UriMaker<UserController> urlMaker) {}
}

I've used to register it with Unity:

container.RegisterType(typeof(UriMaker<>),
    new InjectionConstructor(typeof(UriMakerContext), typeof(HttpRequestMessage)));

but now migrating to Simple Injector. I already have this:

UriMakerContext uriMaker = config.MapHttpAttributeRoutesAndUseUriMaker();
container.RegisterSingle(uriMakerContext);

So how now register UriMaker<> itself?

Answer 1

Although it is possible to configure Simple Injector to allow injecting an UriMaker<TController> directly into your controllers, I strongly advice against this for multiple reasons.

First of all, you should strive to minimize the dependencies your application takes on external libraries. This can easily be done by defining an application specific abstraction (conforming the ISP).

Second, injecting the UriMaker directly makes your extremely hard to test, since the UriMaker is pulled into your test code, while it assumes an active HTTP request and assumes the Web API route system to be configured correctly. These are all things you don't want your test code to be dependent upon.

Last, it makes verifying the object graph harder, since the UriMaker depends on an HttpRequestMessage, which is a runtime value. In general, runtime values should not be injected into the constructors of your services. You should build up your object graph with components (the stuff that contains the application's behavior) and you send runtime data through the object graph after construction.

So instead, I suggest the following abstraction:

public interface IUrlProvider
{
    Uri UriFor<TController>(Expression<Action<TController>> action);
}

Now your controllers can depend on this IUrlProvider instead of depending on an external library:

public class UserController : ApiController
{
    private readonly IUrlProvider urlProvider;

    public UserController(IUrlProvider urlProvider)
    {
        this.urlProvider = urlProvider;
    }

    public string Get()
    {
        this.urlProvider.UriFor<HomeController>(c => c.SomeFancyAction());
    }
}

Under the covers you of course still need to call Drum, and for this you need to define a proxy implementation for IUrlProvider:

public class DrumUrlProvider : IUrlProvider
{
    private readonly UriMakerContext context;
    private readonly Func<HttpRequestMessage> messageProvider;

    public DrumUrlProvider(UriMakerContext context,
        Func<HttpRequestMessage> messageProvider)
    {
        this.context = context;
        this.messageProvider= messageProvider;
    }

    public Uri UriFor<TController>(Expression<Action<TController>> action)
    {
        HttpRequestMessage message = this.messageProvider.Invoke();
        var maker = new UriMaker<TController>(this.context, message);
        return maker.UriFor(action);
    }
}

This implementation can be registered as singleton in the following way:

container.EnableHttpRequestMessageTracking(config);

UriMakerContext uriMakerContext =
    config.MapHttpAttributeRoutesAndUseUriMaker();

IUrlProvider drumProvider = new DrumUrlProvider(uriMakerContext, 
    () => container.GetCurrentHttpRequestMessage());

container.RegisterSingle<IUrlProvider>(drumProvider);

This example uses the Simple Injector Web API integration package to allow retrieving the current request's HttpRequestMessage using the EnableHttpRequestMessageTracking and GetCurrentHttpRequestMessage extension methods as explained here.