Dependency Injection in ASP.NET MVC4 and webapi using Ninject

After using spring.net in ASP.NET for long, I was looking for a simple, fast and no XML Dependency Injector. For an ASP.NET MVC4 application, I finally settled on Ninject because of its no XML approach, simplicity and ease of use.

So, how to choose a Dependency Injector? Well, every Dependency Injector has its strengths and weaknesses and comes with a different feature set. Choosing Dependency Injector is a matter of evaluation and what you expect out of it.

Ninject is an open source Dependency Injector for .NET, created by Nate Kohari, and it comes with a good set of extension and one of them is extension for ASP.NET MVC3.

Anyways, like me, if you also like to try new and promising stuff, you will like to use Ninject , you can read more about Ninject on Ninject.org.

Why Dependency Injection?

There are several benefits of using dependency injection rather than having components satisfy their own dependencies. Some of these benefits are:

• Reduced boiler plate code and dependency carrying, flexibility to use alternative implementation of a given service without recompiling the application code
• Loose coupling between classes by promoting use of interfaces
• Code becomes more reusable, testable and readable. If you are new to DI, you can read more.

What Do We Need to Integrate Ninject in ASP.NET MVC4?

Download Ninject and its ASP.NET MVC3 extension (there is no extension for ASP.NET MVC4 yet).

• You can download it from https://github.com/ninject/ninject/downloads or install it using nuget gallery http://nuget.org/packages/Ninject.MVC3

How to Integrate Ninject in ASP.NET MVC4?

• Add Ninject Dependencies to the project. You need to add reference to following DLLs in your ASP.NET MVC4 project
  1. Ninject.dll
  2. Ninject.Web.Common.dll
  3. Ninject.Web.Mvc.dll
• Modify controller code to declare a read-only member variable of your service and modify the constructor to introduce the service instance parameter as below:
  C#

  8.namespace NinjectMvc4.Controllers
  9.{
  10.    public class HomeController : Controller
  11.    {
  12.        private readonly IMessageService _messageService;
  13.        public HomeController(IMessageService  messageService)
  14.        {
  15.            _messageService = messageService;
  16.        }
  17.
  18.        public ActionResult Index()
  19.        {
  20.            ViewBag.Message = _messageService.GetWelcomeMessage();
  21.            return View();
  22.        }
  23.
  24.    }
  25.}
  

  I have IMesssageService interface and want to inject _messageService with the implementation MessageService using Ninject.

  C#

  6.namespace NinjectMvc4.ServiceLayer
  7.{
  8.    public class MessageService:IMessageService
  9.    {
  10.        public string GetWelcomeMessage()
  11.        {
  12.            return "Welcome to Ninject MVC4 Example";
  13.        }
  14.    }
  15.}
  

• Modify Global.asax, inherit MvcApplication class from abstract class NinjectHttpApplication which is part of Ninject.Web.Common namespace.
• Implement CreateKernel method as follows: Create instance of StandardKernel, Load Executing assembly using the kernel, Bind Service Interface with the implementation to be injected.
• In this example, while constructing the controllers, this will inject the MessageService instance inside HomeController’s constructor so that it can be assigned to _messageService member variable.

14.namespace NinjectMvc4
 15.{
 16.    public class MvcApplication : NinjectHttpApplication
 17.    {
 18.        protected override IKernel CreateKernel()
 19.        {
 20.            var kernel = new StandardKernel();
 21.            kernel.Load(Assembly.GetExecutingAssembly());
 22.            kernel.Bind<IMessageService>().To<MessageService>();
 23.            return kernel;
 24.        }
 25.        protected override void OnApplicationStarted()
 26.        {
 27.            base.OnApplicationStarted();
 28.            AreaRegistration.RegisterAllAreas();
 29.            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
 30.            RouteConfig.RegisterRoutes(RouteTable.Routes);
 31.            BundleConfig.RegisterBundles(BundleTable.Bundles);
 32.        }
 33.    }
 34.}

Override OnApplicationStarted to Register Filters, routes and bundles, etc. (standard ASP.NET MVC4 stuff which we used to do in Application_Start event when not using ninject)

Cool, you are done, let's run the application and see that welcome message is now coming from the MessageService, which got injected into the HomeController.

Ninject is now integrated withASp.NET MVC4, no different than the approach used to integrate it with ASP.NET MVC3.

If you want to integrate it with ASP.NET webapi, (injecting into apicontrollers) using DependencyResolver approach, just implement System.Web.Http.Dependencies.IDependencyResolver on your own.

Why? Because currently Ninject’s Dependency Resolver comes with implementation of System.Web.Mvc.IDependencyResolver which cannot be assigned to GlobalConfiguration.Configuration of WebApi Application, it expects an instance of System.Web.Http.Dependencies.IDependencyResolver instead of System.Web.Mvc.IDependencyResolver, read more about this.

86. public class LocalNinjectDependencyResolver :
    System.Web.Http.Dependencies.IDependencyResolver
87.    {
88.        private readonly IKernel _kernel;
89.
90.        public LocalNinjectDependencyResolver(IKernel kernel)
91.        {
92.            _kernel = kernel;
93.        }
94.        public System.Web.Http.Dependencies.IDependencyScope BeginScope()
95.        {
96.            return this;
97.        }
98.
99.        public object GetService(Type serviceType)
100.        {
101.            return _kernel.TryGet(serviceType);
102.        }
103.
104.        public IEnumerable<object> GetServices(Type serviceType)
105.        {
106.            try
107.            {
108.                return _kernel.GetAll(serviceType);
109.            }
110.            catch (Exception)
111.            {
112.                return new List<object>();
113.            }
114.        }
115.
116.        public void Dispose()
117.        {
118.            // When BeginScope returns 'this', the Dispose method must be a no-op.
119.        }
120.   }

And modify the CreateKernel method as below to assign an instance of LocalNinjectDependencyResolver to GlobalConfiguration.

protected override IKernel CreateKernel()
 46.        {
 47.            var kernel = new StandardKernel();
 48.            kernel.Load(Assembly.GetExecutingAssembly());
 49.            GlobalConfiguration.Configuration.DependencyResolver = 
                                     new LocalNinjectDependencyResolver(kernel); 
 50.            return kernel;
 51.        }

That’s it, we can live with this workaround for now. Please click here if you need to download the sample source code.