Introduction

Most of the projects which are created with dependency are not good for Maintenance because the people which have developed that project are moved to a new project or have left the organization and there is no proper documentation of project which creates problem while maintaining the project. At the means, while there is some change in that project which is to be done fast it creates problem to understand the code. To resolve this kind of problem we are going use Microsoft Unity Framework which will help us to make the project easy to maintain.

"The good project is always easy for Maintenance"

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

We are going to use Constructor Injection in this article because this type is mostly used.

Tools Required.

Visual Studio 2015

SQL Server 2008

Let’s start with creating an MVC Project using Basic Project Template.

Creating Application

Open visual studio IDE on start page select New Project …

Fig 1. Start page

After selecting New Project link a New Project Dialog will Appear Inside that select Templates -> Visual C# inside this select Web after selecting you will see "ASP.NET Web Application" after selecting just name your Project as "MvcInjection" and finally click on OK button to create project.

Selecting Templates

Fig 2. Selecting Template

After clicking on the ok button then another project template selection wizard will pop up with Name "New ASP.NET Project" in this template select MVC Template and we are not going to Create Unit testing for this project hence do not check this option and finally click on OK button.

Fig 3. Selecting MVC Project

After selecting all option as told above now click the OK button your Project will be created.

Project structure after creating MvcInjection project

Fig 4. Project structure

After Creating Project now we are going add Layer in the project [Class library].

Adding MVCInjection.Model [Class library]

First, we are going to add a Model layer with name MVCInjection.Model Layer.

Tips: You might think that we have a Model folder in the project still why we are adding MVCInjection.Model layer because if we have a large project it is better to Move Model in to [Class library] and added a reference to the main project.

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

Fig 5.Steps to add Class library

After selecting New Project a new dialog will pop up with name Add new Project from lets panel select type Visual C# inside that select Windows and from template select [Class Library] and then name your project as MVCInjection.Model and click on Ok button.

Fig 6. Adding MVCInjection.Model [Class library]

Project structure after Adding MVCInjection.Model

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

Adding MVCInjection.Interface [Class library]

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

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

After selecting New Project a new dialog will pop up with name Add new Project from lets panel select type Visual C# inside that select Windows and from template select [Class Library] and then name your project as MVCInjection.Interface and click on Ok button.

Fig 7. Adding MVCInjection.Interface [Class library]

Project structure after Adding MVCInjection.Interface

Now we are going to Add Concrete classes which will implement Interface.

Adding MVCInjection.Concrete [Class library]

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

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

After selecting New Project a new dialog will pop up with name Add new Project from lets panel select type Visual C# inside that select Windows and from template select [Class Library] and then name your project as MVCInjection.Concrete and click on Ok button.

Fig 8. Adding MVCInjection.Concrete [Class library]

Project structure after Adding MVCInjection.Concrete

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

Adding Model in MVCInjection.Model

Next, we are going add a model in [MVCInjection.Model] with name CustomerModel

For adding Model just Right Click on MVCInjection.Model ->Then Select Add -> inside that Select Class.

After Clicking on class Add New Item dialog will pop up with Class selection and asking for the class name here we are going to enter the class name as "CustomerModel".

After adding Model now let’s add some properties to it.

Adding Properties to CustomerModel

namespace MVCInjection.Model
{
    public class CustomerModel
    {
        public int CustomerID { get; set; }
        public string Name { get; set; }
        public string Address { get; set; }
        public string Country { get; set; }
        public string City { get; set; }
        public string Phoneno { get; set; }
    }
}

After completing with adding model and properties now let’s add Interface.

Adding Interface in MVCInjection.Interface

We are going add interface in MVCInjection.Interface.

For adding Interface just Right Click on MVCInjection.Interface ->Then Select Add ->inside that Select Add New Item menu.

After Clicking on Add New item a new Add New Item dialog will pop up inside that select Interface and then we going to name Interface as "ICustomer".

Fig 9. Adding Interface in MVCInjection.Interface

After adding interface now we are going to Add Reference of MVCInjection.Model in MVCInjection.Interface to access Model inside interface.

Adding Reference of MVCInjection.Model (Customer) in MVCInjection.Interface (ICustomer)

To Add Reference just right Click on MVCInjection.Interface [Class Library] then select Add Reference after select a new dialog will pop up with name Reference Manager inside that select MVCInjection.Model and then click on OK button.

After adding Reference now we are going declare some method in the interface.

Declaring method in MVCInjection.Interface

using MVCInjection.Model;
using System.Collections.Generic;

namespace MVCInjection.Interface
{
    public interface ICustomer
    {
        void Add(CustomerModel Customer);     // Create New Customer
        void Update(CustomerModel Customer);  // Modify Customer
        void Delete(CustomerModel Customer);  // Delete Customer
        CustomerModel GetById(int id); // Get an Single Customer details by id
        IEnumerable<CustomerModel> GetAll();  // Gets All Customer details
    }
}

After completing with declaring all method in interface now let’s add Concrete class in MVCInjection.Concrete.

Adding Class in MVCInjection.Concrete

We are going add a class in MVCInjection.Concrete in [Class library] in the project.

For adding Model just Right Click on MVCInjection.Concrete ->Then Select Add -> inside that Select Class.

After Clicking on class Add New Item dialog will pop up with Class selection and asking for the class name here we are going to enter the class name as "CustomerConcrete".

Adding Reference of MVCInjection.Interface (ICustomer) in MVCInjection.Concrete (ICustomer)

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

Now we have completed with adding Reference now let’s Implement all Method declared in ICustomer Interface in CustomerConcrete class.

CustomerConcrete class will implement ICustomer interface.

using MVCInjection.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MVCInjection.Model;

namespace MVCInjection.Concrete
{
    public class CustomerConcrete : ICustomer
    {

      
    }
}

Now to perform all database operation 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 MVCInjection.Concrete [Class Library].

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

Snapshot of Manage NuGet package dialog.

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

Project structure after Adding Dapper

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

Database Part

Here I am going to show some database part.

I have Created Database with the name [CustomerDB].

After that, I have created a table inside CustomerDB database with the name [CustomerTB].

We are going use store procedure for performing CRUD operation.

Below are names of stored procedure which I have created I will provide this store procedure to download.

Connection string Used

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

After Completing with Database part we are again going back to CustomerConcrete class in MVCInjection.Concrete [Class Library].

CustomerConcrete class will implement the ICustomer interface

In this part, I am implementing all method which is declared in the interface and using Dapper to perform Crud operation.

using Dapper;
using MVCInjection.Interface;
using MVCInjection.Model;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;

namespace MVCInjection.Concrete
{
    public class CustomerConcrete : ICustomer
    {

        public void Add(CustomerModel Customer)
        {
            try
            {
                using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
                {
                    con.Open();
                    SqlTransaction sqltans = con.BeginTransaction();
                    var param = new DynamicParameters();
                    param.Add("@CustomerID", Customer.CustomerID);
                    param.Add("@Name", Customer.Name);
                    param.Add("@Address", Customer.Address);
                    param.Add("@Country", Customer.Country);
                    param.Add("@City", Customer.City);
                    param.Add("@Phoneno", Customer.Phoneno);
                    var result = con.Execute("sprocCustomerTBInsertUpdateSingleItem",
                          param,
                          sqltans,
                          0,
                          commandType: CommandType.StoredProcedure);

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

                }
            }
            catch (System.Exception)
            {
                throw;
            }

        }

        public void Update(CustomerModel Customer)
        {
            try
            {
                using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
                {
                    con.Open();
                    SqlTransaction sqltans = con.BeginTransaction();
                    var param = new DynamicParameters();
                    param.Add("@CustomerID", Customer.CustomerID);
                    param.Add("@Name", Customer.Name);
                    param.Add("@Address", Customer.Address);
                    param.Add("@Country", Customer.Country);
                    param.Add("@City", Customer.City);
                    param.Add("@Phoneno", Customer.Phoneno);
                    var result = con.Execute("sprocCustomerTBInsertUpdateSingleItem",
                        param,
                        sqltans,
                        0,
                        commandType: CommandType.StoredProcedure);


                    if (result > 0)
                    {
                        sqltans.Commit();
                    }
                    else
                    {
                        sqltans.Rollback();
                    }
                }
            }
            catch (System.Exception)
            {
                throw;
            }
        }

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

                    if (result > 0)
                    {
                        sqltans.Commit();
                    }
                    else
                    {
                        sqltans.Rollback();
                    }
                }
            }
            catch (System.Exception)
            {
                throw;
            }
        }

        public CustomerModel GetById(int id)
        {
            try
            {
                using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
                {
                    con.Open();
                    var param = new DynamicParameters();
                    param.Add("@CustomerID", id);
                    return con.Query<CustomerModel>("sprocCustomerTBSelectList",
                        param,
                        null,
                        true,
                        0,
                        commandType: CommandType.StoredProcedure).SingleOrDefault();
                }
            }
            catch (System.Exception)
            {
                throw;
            }
        }

        public IEnumerable<CustomerModel> GetAll()
        {
            try
            {
                using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
                {
                    con.Open();
                    var param = new DynamicParameters();
                    return con.Query<CustomerModel>("sprocCustomerTBSelectList",
                        null,
                        null,
                        true,
                        0,
                        commandType: CommandType.StoredProcedure).ToList();
                }
            }
            catch (System.Exception)
            {
                throw;
            }
        }

    }
}

After completing with implementing next we are going to add reference of Model and Interface in Main web Project [MvcInjection].

Adding Reference of Model and Interface to Main Web Project MvcInjection

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

Reference after adding in Project

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

Adding Controller

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

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

I will name Controller as "CustomerController" and in Template, I will choose "MVC controller with empty read/write actions" and finally click on Add button.

Project Structure after Adding CustomerController

CustomerController with all Empty Action Method

Now we are going to add reference of Microsoft Unity Framework to MVCInjection Application.

Adding Microsoft Unity Framework Reference

There are 2 ways of adding Microsoft Unity Framework

Adding Using Manage NuGet package

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

In the search box enter Unity.

And select Unity as shown in below and click on Install button it will get installed.

After adding Unity next we are going to add Unity.MVC package to project as same we have Added Unity, just in the search box enter Unity.MVC and select Unity.MVC as show in below and click on Install button it will get installed.

After Installing Microsoft Unity Framework you should able to see 2 classes UnityConfig class and UnityWebActivator class in Application start folder [App_Start].

Project Structure after Adding Microsoft Unity Framework

After installing Microsoft Unity Framework you will find 2 classes UnityConfig and UnityWebActivator.

UnityConfig: Specifies the Unity configuration for the main container.

UnityWebActivator: Provides the bootstrapping for integrating Unity with ASP.NET MVC.

Below you can see a snapshot of UnityConfig classes.

Register

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

In UnityConfig class we are going to use RegisterTypes Method in this method we are going keep mapping to which Interface the concrete class should resolve.

private readonly ICustomer ICustomer;

 public CustomerController(ICustomer _ICustomer)
 {
     this.ICustomer = _ICustomer;
 }

We have one interface with name ICustomer and other Concrete class with name CustomerConcrete we are registering Type in Unity container.

Here we have Registered Type.

container.RegisterType<ICustomer, CustomerConcrete>();

We should register all types in RegisterTypes Method only.

     public static void RegisterTypes(IUnityContainer container)
     {            
         // TODO: Register your types here
         container.RegisterType<ICustomer, CustomerConcrete>();
     }

This indicates that where ever we are using ICustomer for constructor injection there it should inject CustomerConcrete object.

Now we do not require create object all object creation will be handled by Unity container rather you ask the Unity container to do it for you so that the container can resolve any dependencies.

Now we are going to Use constructor injection we are going to do this in CustomerController.

 private readonly ICustomer ICustomer;

 public CustomerController(ICustomer _ICustomer)
 {
     this.ICustomer = _ICustomer;
 }

At the run time while your constructor gets invoke at that time Unity container will resolve ICustomer interface with CustomerConcrete Class.

Now from constructor injection, we are getting object than from this object we can call all methods of CustomerConcrete Class.

Below is code snippet of CustomerController.

using MVCInjection.Interface;
using MVCInjection.Model;
using System.Web.Mvc;

namespace MvcInjection.Controllers
{
    public class CustomerController : Controller
    {

        private readonly ICustomer ICustomer;

        public CustomerController(ICustomer _ICustomer)
        {
            this.ICustomer = _ICustomer;
        }


        public ActionResult Index()
        {
            var Alldata = ICustomer.GetAll();
            return View(Alldata);
        }

        //
        // GET: /Customer/Details/5

        public ActionResult Details(int id)
        {
            var Detailsdata = ICustomer.GetById(id);
            return View(Detailsdata);
        }

        //
        // GET: /Customer/Create

        public ActionResult Create()
        {
            return View();
        }

        //
        // POST: /Customer/Create

        [HttpPost]
        public ActionResult Create(CustomerModel Customer)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    ICustomer.Add(Customer);
                    return View();
                }
                else
                {
                    return View(Customer);
                }
            }
            catch
            {
                return View();
            }

        }

        //
        // GET: /Customer/Edit/5

        public ActionResult Edit(int id)
        {
            var Editdata = ICustomer.GetById(id);
            return View(Editdata);
        }

        //
        // POST: /Customer/Edit/5

        [HttpPost]
        public ActionResult Edit(CustomerModel Customer)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    ICustomer.Update(Customer);
                    return View();
                }
                else
                {
                    return View(Customer);
                }
            }
            catch
            {
                return View();
            }
        }

        //
        // GET: /Customer/Delete/5

        public ActionResult Delete(int id)
        {
            var Deletedata = ICustomer.GetById(id);
            return View(Deletedata);
        }

        //
        // POST: /Customer/Delete/5

        [HttpPost]
        public ActionResult Delete(CustomerModel Customer)
        {
            try
            {
                ICustomer.Delete(Customer);
                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }
    }
}

After completing accessing all Method of CustomerConcrete Class with in all Action Method Using Unity constructor injection now we are going to add all View of all Action Method one by one.

Adding View of All 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.

Here in 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 Customer and we want to create an input form for that I have selected Create in Scaffold template finally click on Add button.

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

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

Adding Details View

For Adding Details View we are just going to follow the similar step in Model we are going to select Customer and in Scaffold template, we are going to select Details.

Adding Create View

For Adding Create View we are just going to follow the similar step in Model we are going to select Customer and in Scaffold template, we are going to select Create.

Adding Edit View

For Adding Edit View we are just going to follow the similar step in Model we are going to select Customer and in Scaffold template, we are going to select Edit.

Adding Delete View

For Adding Delete View we are just going to follow the similar step in Model we are going to select Customer and in Scaffold template, we are going to select Delete.

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

Project structure after Adding Views

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

To access application we are going to enter URL: - http://localhost:#####/Customer/create

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

Execution of Application only on the first run.

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

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

In below snapshot, it is injecting Concrete class (CustomerConcrete).

We have called Create Action method it will return a View [Create].

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

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

"If you had looked closely the object creation process is moved Out we are No more creating object manually."

Result after Creating Customer [Sql server]

Dependency Injection using Unity Framework with ASP.NET MVC