How to use dependency injection with a controller

FIRST APPROACH

Tip: Use with caution as it may leak Castle Windsor memory.

You need to create a controller activator that needs to implement an interface IControllerActivator

in order to use your DI container to create controller instances:

public class MyWindsorControllerActivator : IControllerActivator
{
    public MyWindsorControllerActivator(IWindsorContainer container)
    {
        _container = container;
    }

    private IWindsorContainer _container;

    public IController Create(RequestContext requestContext, Type controllerType)
    {
        return _container.Resolve(controllerType) as IController;
    }
}

      

        
        
        
      

    

Then add this class to yours DependencyInstaller

:

public class DependencyInstaller : IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.Register(
                // Current code...

                Component.For<IControllerActivator>()
                    .ImplementedBy<MyWindsorControllerActivator>()
                    .DependsOn(Dependency.OnValue("container", container))
                    .LifestyleSingleton();
            );
    }
}

      

        
        
        
      

    

Also create your own dependency transformer based on the Windsor container:

public class MyWindsorDependencyResolver : IDependencyResolver
{
    public MyWindsorDependencyResolver(IWindsorContainer container)
    {
        _container = container;
    }

    private IWindsorContainer _container;

    public object GetService(Type serviceType)
    {
        return _container.Resolve(serviceType);
    }

    public IEnumerable<object> GetServices(Type serviceType)
    {
        return _container.ResolveAll(serviceType).Cast<object>();
    }
}

      

        
        
        
      

    

Then finally, register your dependency transformer in a method Application_Start

in Global.asax.cs:

DependencyResolver.SetResolver(new MyWindsorDependencyResolver(windsorContainer));

      

        
        
        
      

    

This way, when MVC requires a controller activator through its dependency transformer, it will receive ours, which will use our Windsor container to create controllers with all its dependencies.

To avoid using memory leaks IControllerActivator

, the simplest solution would be to use a lifestyle like per thread or per web request rather than standard (Singleton), transient and combined for registered components. Check this link for more information on how to avoid memory leaks using the Castle Windsor container.

SECOND APPROACH

However, as @PhilDegenhardt pointed out, a much better and correct approach would be to implement a custom controller factory to be able to release the controller component created by the Castle Windsor DI container. You can find an example here (see Dependency Injection section) .

Taken from this example, the implementation could be:

Global.asax.cs:

public class MvcApplication : System.Web.HttpApplication
{
    private WindsorContainer _windsorContainer;

    protected void Application_Start()
    {
        var _windsorContainer = new WindsorContainer();
        _windsorContainer.Install(
            new DependencyInstaller(),
            // Other installers...
        );

        ControllerBuilder.Current.SetControllerFactory(new WindsorControllerFactory(_windsorContainer.Kernel));
    }

    protected void Application_End()
    {
        if (_windsorContainer != null)
        {
            _windsorContainer.Dispose();
        }
    }
}

      

        
        
        
      

    

WindsorControllerFactory.cs:

public class WindsorControllerFactory : DefaultControllerFactory
{
    private readonly IKernel _kernel;

    public WindsorControllerFactory(IKernel kernel)
    {
        _kernel = kernel;
    }

    public override void ReleaseController(IController controller)
    {
        _kernel.ReleaseComponent(controller);  // The important part: release the component
    }

    protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
    {
        if (controllerType == null)
        {
            throw new HttpException(404, string.Format("The controller for path '{0}' could not be found.", requestContext.HttpContext.Request.Path));
        }
        return (IController)_kernel.Resolve(controllerType);
    }
}