ASP.NET MVC 3: Dependency injection with Unity 2.0

Update 2011-07-03: I’ve written a new blog post “ASP.NET MVC 3 & Unity 2.0: Using XML configuration for design-time configuration” that shows how to use XML configuration to set up the Unity dependency injection container.

Update 2011-03-28: I’ve fixed an error in the Application_Start method and added a sample Visual Studio 2010 project that includes a running ASP.NET MVC 3 web application with the source code of this post (download).

This blog posts shows a step-by-step instruction how to integrate the Unity 2.0 dependency injection container in an ASP.NET MVC 3 web application.

Create MVC 3 project and add Unity 2.0

Create a new “ASP.NET MVC 3 Web Application” project in Visual Studio 2010. For simplicity, we will use the project template “Internet Application”, which adds some some sample controllers and views to the project.
Download Unity 2.0 here from MSDN and run the setup. By default, the setup will extract all Unity files to C:\Program Files (x86)\Microsoft Unity Application Block 2.0\. Copy all dll files from the subfolder bin into your ASP.NET MVC 3 project. It is recommended to save them in a new subfolder (for example “libs”) in your project. In detail, the project should now contain the following the dll files:

  • Microsoft.Practices.ServiceLocation.dll
  • Microsoft.Practices.Unity.Configuration.dll
  • Microsoft.Practices.Unity.dll
  • Microsoft.Practices.Unity.Interception.Configuration.dll
  • Microsoft.Practices.Unity.Interception.dll

In the Solution Explorer, right click on “References” and click on “Add Reference…” and select these five dll files in the tab “Browse” to reference the libraries in your project.

Register MVC 3 DependencyResolver

To use the Unity dependency injection container in the newly created ASP.NET MVC 3 project we first need an adapter class, that implements the interface IDependencyResolver and maps the method calls to a concrete Unity dependency injection container (an instance of IUnityContainer, see this post):

public class UnityDependencyResolver : IDependencyResolver
{
  readonly IUnityContainer _container;
  public UnityDependencyResolver(IUnityContainer container)
  {
    this._container = container;
  }
  public object GetService(Type serviceType)
  {
    try
    {
      return _container.Resolve(serviceType);
    }
    catch
    {
      return null;
    }
  }
  public IEnumerable<object>GetServices(Type serviceType)
  {
    try
    {
      return _container.ResolveAll(serviceType);
    }
    catch
    {
      return new List<object>();
    }
  }
}

In the Global.asax.cs file we will set up a Unity dependency injection container in the Application_Start method and use our little adapter class to register the Unity container as the service locator for the ASP.NET MVC application.

protected void Application_Start()
{
  [...]
 
  var container = new UnityContainer();
  container.RegisterType<IMessages, Messages>();
  DependencyResolver.SetResolver(new UnityDependencyResolver(container));
}

In the above code, we also register a type with the container using the RegisterType method (you can find detailed information about configuring the Unity container and in the MSDN library).
In this simplified example, we just register the type IMessages with the concrete implementation Messages. The next section shows how this type is implemented and used.

Resolving dependencies

To test the dependency resolving, we modify the HomeController.cs and add a new property Messages which is annotated with the Dependency attribute and use this property in the Index action:

public class HomeController : Controller {
 
  [Dependency]
  public IMessages Messages { get; set; }
 
  public ActionResult Index()
  {
    ViewBag.Message = Messages.Welcome;
    return View();
   }
 
  [...]
}

Of course, before we can build our ASP.NET application we need to implement the IMessages interface and Messages class:

public interface IMessages
{
  String Welcome { get; }
}
 
public class Messages : IMessages
{
  string IMessages.Welcome
  {
    get { return "Hello world from Unity 2.0!"; }
  }
}

After building and starting the application the Unity dependency injection container should resolve the dependency that is defined in the HomeController and the application’s start page should say “Hello world from Unity 2.0!”.

ASP.NET MVC3 and Unity 2.0 screenshot

You can download a sample Visual Studio 2010 project containing all the source code here.