Question

I’m trying to resolve a dependency like this:

controller.ActionInvoker = kernel.Resolve<IActionInvoker>(controller.GetType());

It was previously registered in this way:

container.Register(
    Component
        .For<IActionInvoker>()
        .ImplementedBy<WindsorActionInvoker>()
        .UsingFactoryMethod(metho)
        .LifestylePerWebRequest()
);


internal IActionInvoker metho(IKernel kernel,ComponentModel model, CreationContext context)
{
    // here just for debugging and watching the variables in the factory method, 
    // I would instance WindsorActionInvoker passing the filters to inject.
    throw new InvalidOperationException();
}

But I can’t figure out how to get the parameter I passed to the resolve call in the factory method.

I need the Type I’m passing as parameter to pass it to one of the dependencies injected into the constructor of the concrete type.

What am I doing wrong?

---

If you must know, the purpose of this is to inject action filters directly into the action invoker (and therefore the controllers), instead of requiring them decorate a controller or the base controller, additionally, this lets me to inject parameters dynamically, which I can’t do with attributes.

public class WindsorActionInvoker : ControllerActionInvoker
{
    private readonly IList<IActionFilter> actionFilters;
    private readonly IList<IAuthorizationFilter> authorizationFilters;
    private readonly IList<IExceptionFilter> exceptionFilters;
    private readonly IList<IResultFilter> resultFilters;

    public WindsorActionInvoker(IList<IActionFilter> actionFilters, IList<IAuthorizationFilter> authorizationFilters, IList<IExceptionFilter> exceptionFilters, IList<IResultFilter> resultFilters)
    {
        if (actionFilters == null)
        {
            throw new ArgumentNullException("actionFilters");
        }
        if (authorizationFilters == null)
        {
            throw new ArgumentNullException("authorizationFilters");
        }
        if (exceptionFilters == null)
        {
            throw new ArgumentNullException("exceptionFilters");
        }
        if (resultFilters == null)
        {
            throw new ArgumentNullException("resultFilters");
        }
        this.actionFilters = actionFilters;
        this.authorizationFilters = authorizationFilters;
        this.exceptionFilters = exceptionFilters;
        this.resultFilters = resultFilters;
    }

    protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
    {
        FilterInfo filterInfo = base.GetFilters(controllerContext, actionDescriptor);
        foreach (IActionFilter filter in actionFilters)
        {
            filterInfo.ActionFilters.Add(filter);
        }
        foreach (IAuthorizationFilter filter in authorizationFilters)
        {
            filterInfo.AuthorizationFilters.Add(filter);
        }
        foreach (IExceptionFilter filter in exceptionFilters)
        {
            filterInfo.ExceptionFilters.Add(filter);
        }
        foreach (IResultFilter filter in resultFilters)
        {
            filterInfo.ResultFilters.Add(filter);
        }
        return filterInfo;
    }
}

Answer 1

Solved, I needed to pass either a dictionary or an anonymous type instead of just any object.

Replacing:

controller.ActionInvoker = kernel.Resolve<IActionInvoker>(controller.GetType());}

With

controller.ActionInvoker = kernel.Resolve<IActionInvoker>(new { loggerType = controller.GetType() });

Fixed it.

🙂