Resolving a dependency while supplying values for downstream dependencies

Question

I've been running into endless problems attempting to use Windsor with Web API and injecting HttpRequestMessage into downstream dependencies of a controller. Since I've tried all the matching answers on Stackoverflow, I'd like to ask the question in a different way:

In Castle Windsor, how can I resolve a component instance while supplying a value for a downstream dependency? That is, the supplied value is required by a component that is required by the component being resolved.

For context, I'm trying to inject HttpRequestMessage so that I can use it to resolve the request context (primarily to resolve an absolute URL).

Edit I'd also like to point out that I don't currently have a dependency on Web Host / System.Web and I'd rather not change that.

Answer 1

A proper approach is to

1. Create IMyDesiredRouteParameterProvider
2. Implement it. Get the current request inside it and get the url
3. Register it and inject it in the desired dependent class via constructor.

I made myself such an implementation and I can say that this way it works fine. You can make Web.Infrastructure assembly and put the implementation there. Or put both the interface and the implementation there if you are going to reference it from another web module.

using System;
using System.Web;

namespace RouteParameterProvider
{
    interface IMyRouteParameterProvider
    {
        string GetRouteParameter();
    }

    public class ControllerActionMethodRouteParameterProvider : IMyRouteParameterProvider
    {
        public string GetRouteParameter()
        {
            string Parameter = HttpContext.Current.Request.RequestContext.RouteData.Values["controller"] as string;
            if (string.IsNullOrEmpty(Parameter))
            {
                throw new InvalidOperationException();
            }
            return Parameter;
        }
    }
}

You can get every possible thing that the Request Context contains from :

HttpContext.Current.Request.RequestContext

And it will be better if you rethink your design decision :

I need HttpRequestMessage to be regstered prior to creating each instance of SomethingController so that it will be available down at the LinkGenerator layer.

Containers are to be initialized at runtime and then used to resolve.

Answer 2

I need HttpRequestMessage to be regstered prior to creating each instance of SomethingController so that it will be available down at the LinkGenerator layer.

It sounds like you want to register an item with the container at runtime, post-startup. In general, this is not a good practice--registration should be a discrete event that happens when the app is fired up, and the container's state should not be changed during runtime.

Dependency Injection is about resolving service components, not runtime state--state is generally passed via methods (method injection). In this case it sounds like your LinkGenerator component needs access to the ambient state of the request.

I'm not that familiar with HttpRequestMessage, but this answer seems to show that it is possible to retreive it from HttpContext.Current. You could make this a method on your LinkGenerator class, or wrap this call in a separate component that gets injected into LinkGenerator (HttpRequestMessageProvider?). The latter would be my preferred method, as it allows LinkGenerator to be more testable.

Answer 3

Given the lack of a clean way of doing this and Web API not providing information as to the hosted endpoint beyond per-request context objects, I ended up injecting the base url from configuration.

Answer 4

Is this library by Mark Seemann the answer? In the description he writes explicitly :

This approach enables the use of Dependency Injection (DI) because the request can be injected into the services which require it.

Then gives an example :

// Inside an ApiController

var uri = this.Url.GetLink(a=> a.GetById(1337));

By which you can then pass the URL down the road in the service that you have injected in the controller.

UPDATE : Mark Seemann wrote about the same exact problem here:

"Because HttpRequestMessage provides the context you may need to compose dependency graphs, the best extensibility point is the extensibility point which provides an HttpRequestMessage every time a graph should be composed. This extensibility point is the IHttpControllerActivator interface:..."

This way you can pass request context information to a component deep in the object graph by getting from the HttpRequestMessage and passing it to the DI container. Just take a look at the interface of IHttpControllerActivator.

The WEB API framework gets the IHttpControllerActivator through DependencyResolver. You probably already replaced it by your CastleWindsorDependencyResolver. Now you have to implement and register your HttpControllerActivator and register it.

When the WEB API framework gets IHttpControllerActivator from DependencyResolver (your Castle Windsor DR) and calls IHttpControllerActivator.Create() it will pass you the HttpRequestMessage. You can get your info from there and pass it to the your CastleDR before you call Resolve(typeof(MyController)) which will resolve the whole object graph - that means you will have MyHttpContextInfo to inject in your XYZComponent deep in the resolution stack.

This way tou are passing the arguments in the last possible moment but it is still possible. In Castle Windsor I make such passing of arguments though CreationContext.AdditionalArguments["myArgument"];.