Many thanks to the original source by ArtisanCode on GitHub I’ve enjoyed for solving this problem. You may also enjoy Radenko’s post and Raymund’s post. I hope that you will find what I have learned from these sources helpful. The requirement was running ASP.NET MVC and Web API in the same project with a single inversion of control (IoC) container shared by both, though I never ended up using injection for my MVC controllers as I had planned.
My personal preference in the past has been Castle Windsor, in part because I like the ability to do interception so easily. More on interception in a future post. For now, have a look at how easy it is to wire up. First, we wire up the container in the Application_Start method in your Global.asax.cs class that inherits from System.Web.HttpApplication:
IoC.Instance.Container.Install(new DependencyConfig());
IoC.Instance.Container.BeginScope();
GlobalConfiguration.Configuration.DependencyResolver =
new CastleDependencyResolver(IoC.Instance.Container);
Then we wire up the DependencyConfig class mentioned in the above snippet.
public class DependencyConfig : IWindsorInstaller
{
public void Install(IWindsorContainer container, IConfigurationStore store)
{
//... config stuff ... blah blah blah
//register a component with a custom interceptor for capturing some aspect
container.Register(Component.For<IMyComponent>()
.ImplementedBy<MyComponent>()
.LifestyleSingleton()
.Interceptors(InterceptorReference.ForType<MyInterceptor>())
.Anywhere);
And implement your interceptor with something like this:
public class MyInterceptor : IInterceptor
{
public void Intercept(IInvocation invocation)
{
//do something before the call is executed
//execute the call
invocation.Proceed();
//do something after the call is executed
}
}
Now put it all together and you have ApiControllers injecting your components for you. And you can get components directly when you need them using the IoC singleton I wrote like this:
var mycomp = IoC.Instance.Container.Resolve<IMyComponent>();
Here’s the IoC singleton:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Castle.Windsor;
namespace MyCastle
{
public class IoC
{
private static volatile IoC _instance;
private static object _syncRoot = new object();
private readonly WindsorContainer container;
private IoC()
{
container = new WindsorContainer();
}
public static IoC Instance
{
get
{
if (null == _instance)
{
lock (_syncRoot)
{
if (null == _instance)
{
_instance = new IoC();
}
}
}
return _instance;
}
}
public WindsorContainer Container { get { return container; } }
}
}
And where does the CastleDependencyResolver and CastleDependencyScope classes come from? That’s the fun part. First, you’ll need two NuGet packages:
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="Castle.Core" version="3.3.3" targetFramework="net45" />
<package id="Castle.Windsor" version="3.3.0" targetFramework="net45" />
</packages>
Then you just need the ArtisanCode code for those two classes. For my own use, I’ve modified them a bit in my own projects but you may find that you can use them right out of the box or even adopt the entire WebApiCastleIntegration library.
There you have it.