How to Use Ninject Framework with MVC

Most people think that IOC containers are for large applications only. They are wrong, as they can be used in any size application; i.e, from small to large, because this will make your application maintainable and improve the quality of your application.

Some people have another question in mind, which is: How much does it cost to get IOC Containers?

Oh, most IOC containers are free to download and use.

In this, Ninject is completely free to use for personal and commercial projects.

You can check here for more information.



What is Ninject framework?

The Ninject framework is an ultra-lightweight framework from Ninject, which will help us to resolve dependency.

What is Dependency injection?

Dependency injection is a design pattern, which is used to remove hard code dependency.

Types of Injection

• Constructor Injection
• Property Setter Injection (Properties)
• Method Injection

If you have a look at the internet, you will find most people show an example of Constructor Injection. In this article, I will show you how to use all the three types of injectios.

Tools Required for Demo,

• Visual Studio 2012
• SQL Server 2008

Let’s start with creating an MVC project, using a basic project template.

Creating Application

Open Visual Studio IDE on the start page. Select new project.


Figure 1. Start page

After selecting new project link, a new project dialog will appear. Inside it, select templates - Visual C# needs to be selected inside this. Select Web, after which you will see the various project templates (Webforms , MVC , Asp.net AJAX Server control). In this, select “ASP.NET MVC 4 Web Application. ” After selecting, just name your project as “MvcNInject” and finally click the OK button to create the project.

Selecting Templates


Figure 2. Selecting Template

After clicking OK button, another project template selection wizard will pop up with the name “New ASP.NET MVC 4 Project.” In this template, select basic template, set view engine as Razor and we are not going to create unit testing for this project. Hence, do not check this option and finally click OK button and it's done.


Figure 3. Selecting MVC 4 Project

After selecting all the options, as told above, click OK button and your project will be created.

Project structure after creating MvcNInject project


Figure 4. Project structure

After creating our project, we are going to add class Library to the project, so that it feels like a real application when we create it.

Adding [Class library] to Web project

We are going to Add three [Class libraries].

1. MvcNInject.Model
2. MvcNInject.Interface
3. MvcNInject.Concrete

MvcNInject.Model [Class library] will contain all the models.
MvcNInject.Interface [Class library] will contain all the interfaces.
MvcNInject.Concrete [Class library] will contain all the concrete classes.

Let’s start doing it.

Adding MvcNInject.Model [Class library]

First, we are going to add Model layer with the name MvcNInject.Model Layer.

Tips

You might think since we have Model folder in the project, then why are we adding MvcNInject.Model layer? It is because if we have a large project, it is better to move Model into [Class library] and add reference to the main project.

To add [Class library], just right click on your project from the list and select Add, followed by selecting the new project.


Figure 5. Steps to add Class library

After selecting the new project, a new dialog will pop up with the name Add New Project. As shown below, select the type Visual C# inside it. Select Windows and from the template, select [Class Library] and then name your project as MvcNInject.Model and click OK button.


Figure 6. Adding MvcNInject.Model [Class library]

Project structure after Adding MvcNInject.Model



Now we are going to Add Interface to make your application's loose couple.

Adding MvcNInject.Interface [Class library]

We are going to add MvcNInject.Interface in a similar way as we have added MvcNInject.Model [Class library].

To add [Class library] just right click on your project from List and select Add - then select New Project.

After selecting a new project, a new dialog will pop up with the name Add new Project from the panel and select type Visual C#. Inside it, select Windows. From the template, select [Class Library] and then name your project as MvcNInject.Interface and click OK button.


Figure 7. Adding MvcNInject.Interface [Class library]

Project structure after Adding MvcNInject.Interface



Now, we are going to add concrete classes, which will implement an interface.

Adding MvcNInject.Concrete [Class library]

We are going to add MvcNInject.Concrete in a similar way as we have added MvcNInject.Interface [Class library].

To add [Class library], just right click on your project from the list, select Add followed by selecting the New Project.

After selecting New Project, a new dialog will pop up with the name Add new Project from the panel. Select type Visual C#; inside it, select Windows from the template, select [Class Library], name your project as MvcNInject.Concrete and click OK button.


Figure 8. Adding MvcNInject.Concrete [Class library]

Project structure after Adding MvcNInject.Concrete



Now, we have completed adding all [Class library] in the project.

Adding Model in MvcNInject.Model

Next, we are going add a model in [MvcNInject.Model] with the name Event.

For adding model, just right click on MvcNInject.Model, and select Add, followed by selecting the class inside it.

After clicking on the class, add new item and a  dialog will pop up with the class. Select and it will ask for the class name. Here, we are going to enter the class name as an “Event”.



After adding the model, let’s add some properties to it.

Adding Properties to EventModel

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MvcNInject.Model
{
    public class EventModel
    {
        [Key]
        public int EventID { get; set; }
        public string EventName { get; set; }
        public string EventStarts { get; set; }
        public string EventEnds { get; set; }
        public string EventLocation { get; set; }
    }
}

After adding the model and properties, now let’s add an interface.

Adding Interface in MvcNInject.Interface

We are going add an interface in MvcNInject.Interface.

To ad an interface, just right click on MvcNInject.Interface followed by selecting add. Inside it, select Add New Item menu.

After clicking Add New item, a new Add New item dialog will pop up. Inside it, select an interface and then we are going to name an interface as an “IEvent”.

s
Figure 9. Adding Interface in MvcNInject.Interface



After adding an interface, we are going to add the reference of MvcNInject.Model in MvcNInject.Interface to access the model inside an interface.

Adding Reference of MVCNInject.Model (Event) in MVCNInject.Interface (IEvent)

To add a reference, just right click on MvcNInject.Interface [Class Library], followed by selecting add reference. After selecting, a new dialog will pop up with the name Reference Manager. Inside it, select MvcNInject.Model and click OK button.




Figure 10. Adding reference of MvcNInject.Model to MvcNInject.Interface

After adding reference now, we are going to declare some method in an interface.

Declaring method in MvcNInject.Interface 

using MvcNInject.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MvcNInject.Interface
{
    public interface IEvent
    {
        void Add(EventModel _Event);     // Create New Event
        void Update(EventModel _Event);  // Modify Event
        void Delete(EventModel _Event);  // Delete Event
        EventModel GetById(int id); // Get an Single Event details by id
        IEnumerable<EventModel> GetAll();  // Gets All Event details
    }
}

After declaring all the methods in an interface, let’s add concrete class in MvcNInject.Concrete.

Adding Class in MVCNInject.Concrete

We are going to add class in MvcNInject.Concrete in [Class library] in the project.

To add the model, just right click on MvcNInject.Concrete. Select Add - inside that Select Class.

After Clicking on class, add new item and a dialog will pop up with class select and ask for class name; here we are going to enter class name as “EventConcrete”.



Adding Reference of MvcNInject.Interface (Event) in MvcNInject.Concrete (IEvent)

To Add Reference just right Click on MvcNInject.Concrete [Class Library] then select Add Reference; after selecting a new dialog will pop up with the name Reference Manager; inside that select MvcNInject.Interface and MvcNInject.Model. Both are required, then click on OK button.


Figure 11. Adding reference of MvcNInject.Interface and MvcNInject.Model to MvcNInject.Concrete

Now we have finished adding Reference, now let’s implement all methods declared in IEvent Interface in EventConcrete class.

EventConcrete class will implement IEvent interface

using MvcNInject.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MvcNInject.Concrete
{
    public class EventConcrete : IEvent
    {

    }
}

Now after implementing IEvent interface next we are going perform CRUD operation using Dapper ORM.

Adding Dapper ORM to MvcNInject.Concrete [Class Library]

Now to perform all database operations such as CRUD I am going to use Dapper ORM.

We are going add Reference of Dapper ORM from NuGet package manager and we are going add it in MvcNInject.Concrete [Class Library].

To open Manage NuGet Package dialog just right click on MvcNInject.Concrete [Class Library] and from the list select Manage NuGet package.

Snapshot of Manage NuGet package dialog.

In search box enter Dapper. And select Dapper dot net as show below and click on Install button.


Figure 12. Adding DapperORM from NuGet

Project structure after Adding Dapper



After adding Dapper ORM next we Create Database and Table and Store procedure for performing CRUD operation.

Database Part

Here I am going to show the database part.

I have created a Database with the name [EventDB].



After that I have created a table inside EventDB database with name [EventTB].


Figure 13. Table structure

We are going use stored procedure for performing CRUD operation.

Below are the names of the stored procedure which I have created. I have provided this stored procedure to download.


Connection string used

<connectionStrings>
   <add name="DefaultConnection"
   providerName="System.Data.SqlClient"
   connectionString="Data Source=sai-pc;Database=EventDB;UID=sa;Password=Pass$123" />
</connectionStrings>

After Completing the Database part we are again going back to EventConcrete class in MvcNInject.Concrete [Class Library].

EventConcrete class will implement IEvent interface

In this part I am implementing all methods which are declared in interface and using Dapper to perform Crud operation.

using Dapper;
using MvcNInject.Interface;
using MvcNInject.Model;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MvcNInject.Concrete
{
    public class EventConcrete : IEvent
    {
        public void Add(EventModel Event)
        {
            using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
            {
                con.Open();
                SqlTransaction sqltans = con.BeginTransaction();
                var param = new DynamicParameters();
                param.Add("@EventID", Event.EventID);
                param.Add("@EventName", Event.EventName);
                param.Add("@EventStarts", Event.EventStarts);
                param.Add("@EventEnds", Event.EventEnds);
                param.Add("@EventLocation", Event.EventLocation);
                var result = con.Execute("sprocEventTBInsertUpdateSingleItem",
                      param,
                      sqltans,
                      0,
                      commandType: CommandType.StoredProcedure);

                if (result > 0)
                {
                    sqltans.Commit();
                }
                else
                {
                    sqltans.Rollback();
                }

            }

        }

        public void Update(EventModel Event)
        {
            using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
            {
                con.Open();
                SqlTransaction sqltans = con.BeginTransaction();
                var param = new DynamicParameters();
                param.Add("@EventID", Event.EventID);
                param.Add("@EventName", Event.EventName);
                param.Add("@EventStarts", Event.EventStarts);
                param.Add("@EventEnds", Event.EventEnds);
                param.Add("@EventLocation", Event.EventLocation);
                var result = con.Execute("sprocEventTBInsertUpdateSingleItem",
                    param,
                    sqltans,
                    0,
                    commandType: CommandType.StoredProcedure);


                if (result > 0)
                {
                    sqltans.Commit();
                }
                else
                {
                    sqltans.Rollback();
                }
            }
        }

        public void Delete(EventModel Event)
        {
            using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
            {
                con.Open();
                SqlTransaction sqltans = con.BeginTransaction();
                var param = new DynamicParameters();
                param.Add("@EventID", Event.EventID);
                var result = con.Execute("sprocEventTBDeleteSingleItem",
                    param,
                    sqltans,
                    0,
                    commandType: CommandType.StoredProcedure);

                if (result > 0)
                {
                    sqltans.Commit();
                }
                else
                {
                    sqltans.Rollback();
                }
            }
        }

        public EventModel GetById(int id)
        {
            using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
            {
                con.Open();
                var param = new DynamicParameters();
                param.Add("@EventID", id);
                return con.Query<EventModel>("sprocEventTBSelectSingleItem",
                    param,
                    null,
                    true,
                    0,
                    commandType: CommandType.StoredProcedure).SingleOrDefault();
            }
        }

        public IEnumerable<EventModel> GetAll()
        {

            using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
            {
                con.Open();
                var param = new DynamicParameters();
                return con.Query<EventModel>("sprocEventTBSelectList",
                    null,
                    null,
                    true,
                    0,
                    commandType: CommandType.StoredProcedure).ToList();
            }
        }



    }
}

After completing the implementation next we are going to add reference of Model and Interface in Main web Project [MvcNInject].

Adding Reference of Model and Interface to Main Web Project MvcNInject

To Add Reference just right Click on MvcNInject then select Add Reference; after selecting a new dialog will pop up with the name Reference Manager, inside that select MvcNInject.Interface , MvcNInject.Model , MvcNInject.Concrete which are required then click on OK button.


Figure 14. Adding reference of all three class libraries to main Web Project (MvcNInject)

Reference after adding in Project

After adding this reference now let’s Add a Controller with the name EventController

Adding Controller

For adding Controller Just Right click on Controller Folder, inside that select Add, and then select Controller.

After clicking on Controller a new dialog will pop up with the name Add Controller.

I will name Controller “EventController” and in Template I will choose “MVC controller with empty read/write actions” and finally click on the Add button.


Figure 15. Adding Event Controller

Project Structure after Adding EventController



EventController with all Empty Action Method


Figure 15. All Action Method of Event Controller

After adding Controller now we are going to add reference of Ninject Framework to MvcNInject Application.

Adding Ninject Framework Reference



There are two ways of Installing Microsoft Unity Framework,

Installing Using Manage NuGet package

To open Manage NuGet Package dialog just right click on MvcNInject and from List select Manage NuGet package.

In search box enter Ninject MVC4.

And select Ninject.MVC4 as show below and click on Install button and it will get installed.


Figure 16. Installing Ninject framework

Installing Using Package Manager Console

To install Ninject Framework using Package Manager Console, first from IDE menu select Tools - then NuGet package Manager - inside that select Package Manager Console.

In Package Manager Console enter Command: Install-Package Ninject.MVC4



After entering command just press enter button it will get Installed.



After Installing Ninject Framework you should be able to see one class, NinjectWebCommon class, in the Application start folder [App_Start].

Project Structure after Adding Ninject Framework



Below you can see a snapshot of NinjectWebCommon classes.


Figure 17. NinjectWebCommon class preview

After that we are going to add class with name NinjectResolver which will store all Mapping of Registered Types in it.

A NinjectResolver will inherit System.Web.Mvc.IDependencyResolver,

using Ninject;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MvcNInject.App_Start
{
    public class NinjectResolver: System.Web.Mvc.IDependencyResolver
    {
        private readonly IKernel _kernel;

        public NinjectResolver()
        {
            _kernel = new StandardKernel();
            AddBindings();
        }
        public object GetService(Type serviceType)
        {
            return _kernel.TryGet(serviceType);
        }
        public IEnumerable<object> GetServices(Type serviceType)
        {
            return _kernel.GetAll(serviceType);
        }
        private void AddBindings()
        {
           // _kernel.Bind<To, From>(); // Registering Types
        }
    }

}

Registering Types in Ninject

Now we are going registers all the type mappings with the Ninject container.


Figure 18. Ninject

Now we are going to register types in NinjectResolver classes;  we have a method with name AddBindings() in which we are going to register.

private void AddBindings()
{
   this._kernel.Bind<IEvent>().To<EventConcrete>(); // Registering Types
}

This indicates that whereever we are using IEvent for constructor injection it should inject EventConcrete object there.

In this method you can register all your mapping of your application.

Now we are required to create object; all object creation will be handled by Ninject container; which is to say you ask the Ninject container to do it for you so that the container can resolve any dependencies.

Here is complete NinjectResolver Class View.

NinjectResolver Class

using MvcNInject.Concrete;
using MvcNInject.Interface;
using Ninject;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MvcNInject.App_Start
{
    public class NinjectResolver: System.Web.Mvc.IDependencyResolver
    {
        private readonly IKernel _kernel;

        public NinjectResolver()
        {
            _kernel = new StandardKernel();
            AddBindings();
        }

        public object GetService(Type serviceType)
        {
            return _kernel.TryGet(serviceType);
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            return _kernel.GetAll(serviceType);
        }

        private void AddBindings()
        {
            this._kernel.Bind<IEvent>().To<EventConcrete>(); // Registering Types
        }
    }

}

Now one final step is remaining, we have just registered Types in NinjectResolver class and we need to call this class in Global.asax Application_Start() Method.

In Application_Start() method we are going to call our NinjectResolver class.

DependencyResolver.SetResolver(new NinjectResolver());

Below you can see the complete Global.asax Class.

NinjectResolver Class

using MvcNInject.App_Start;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Http;
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;

namespace MvcNInject
{
    public class MvcApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            DependencyResolver.SetResolver(new NinjectResolver());// Calling  NinjectResolver Class

            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
        }
    }
}

After completing with calling class in Global.asax now we are going to move forward to EventController and in this controller we are going to implement Constructor Injection.

public class EventController : Controller
{
     private readonly IEvent _IEvent;

     public EventController(IEvent IEvent)
     {
         _IEvent = IEvent;
     }
}

Below is the code snippet of EventController.

using MvcNInject.Interface;
using MvcNInject.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
namespace MvcNInject.Controllers
{
    public class EventController : Controller
    {
        private readonly IEvent _IEvent;

        public EventController(IEvent IEvent)
        {
            _IEvent = IEvent;
        }


        public ActionResult Index()
        {
            var Data = _IEvent.GetAll();
            return View(Data);
        }
        //
        // GET: /Event/Details/5

        public ActionResult Details(int id)
        {
            var Data = _IEvent.GetById(id);
            return View(Data);
        }
        //
        // GET: /Event/Create

        public ActionResult Create()
        {
            return View();
        }
        //
        // POST: /Event/Create

        [HttpPost]
        public ActionResult Create(EventModel EventModel)
        {
            try
            {
                _IEvent.Add(EventModel);
                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }
        //
        // GET: /Event/Edit/5

        public ActionResult Edit(int id)
        {
            var Editdata = _IEvent.GetById(id);
            return View(Editdata);
        }
        //
        // POST: /Event/Edit/5

        [HttpPost]
        public ActionResult Edit(EventModel EventModel)
        {
            try
            {
                _IEvent.Update(EventModel);
                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }
        //
        // GET: /Event/Delete/5
        public ActionResult Delete(int id)
        {
            var Deletedata = _IEvent.GetById(id);
            return View(Deletedata);
        }
        //
        // POST: /Event/Delete/5
        [HttpPost]
        public ActionResult Delete(EventModel EventModel)
        {
            try
            {
                _IEvent.Delete(EventModel);
                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }
    }
}

After completing the accessing of all Method of EventConcrete Class within all Action Method Using NInject constructor injection, now we are going to add all View of all Action Method one by one.

Adding View (Create / Update / Delete / Index)

For Adding View just right click inside Index ActionResult Method and Select "Add View" to create the view template for our Index form.


Figure 19. Adding Views of all Action Method.

Here in the below snapshot I have selected View engine as Razor and we are going to create a strongly typed view, for that I have selected Model class EventModel and we want to create an input form, for that I have selected Create in Scaffold template, finally click on Add button.


Figure 20. Steps for Adding View

After clicking on Add button the View will get created and it is stored in the Views folder; inside this folder, there I created a folder with the same name as Controller [Event]; inside that this View will be placed.

In a similar way we are going to Add View for all Action Methods.

Adding Details View

For Adding Details View we are just going to follow a similar step --  in Model we are going to select Event and in Scaffold template we are going to select Details.

Adding Create View

For Adding Create View we are just going to follow a similar step --  in Model we are going to select Event and in Scaffold template we are going to select Create.

Adding Edit View

For Adding Edit View we are just going to follow a similar step --  in Model we are going to select Event and in Scaffold template we are going to select Edit.

Adding Delete View

For Adding Delete View we are just going to follow a similar step --  in Model we are going to select Event and in Scaffold template we are going to select Delete.

After completing adding all View,  your Views Folder should look like this as show below.

Project structure after Adding Views



Now we have completed adding Views, let’s run the application.

Run Application

To access the application we are going to enter URL: http://localhost:#####/ Event/Create

(##### is local host port number).

After running application we are going to see how constructor injection takes place.

By attaching debugger at constructor you can check what is getting injected.

Debugging Preview of EventController while Constructor is injecting


Figure 21. Debugging Preview of Event Controller while Constructor is injecting



After having a look on the debugging process we have called Create Action method and it will return a View [Create].

Create View


Figure 22. Accessing Create View for inserting data

So far we have done constructor injection.

Now let’s have a look at Property Setter Injection.

Property Injection

Here I have created Property with name [_Event];  to inject in property we need to Use [Inject] attribute on top of the Property where you want it.

See below example.

[Inject]
public IEvent _Event { set; get; }

Debugging Preview of EventController while Using Property injecting

If you have looked closely then you can see I have commented Constructor; and still we are able to inject using Property injection.


Figure 23. Property Injection

Method Injection

Here I have created Method Injection. To use this just create a Method with any unique name, I have named it DemoMethod and this method should take the Interface as Parameter, after that, on that method, just add [Inject] Attribute.

[Inject]
public void DemoMethod(IEvent IEvent)
{
   _IEvent = IEvent;
}

Figure 24. Method Injection

After entering data I am going to click on Create button to save data in the database.

Let’s check your table --  EventTB has data inserted in it. Yes, it is there.

Result after Creating Event [Sql server]


Figure 25. Sql Query

In a similar way we can access all views which we have created.

If you have looked closely the object creation process is moved out;  we are no longer creating the object manually.

Finally we have come a long way and step by step learned how to use NInject with MVC.

Download source code from here.