How to use Unity DI(Dependency Injection) in asp.net MVC 5

  ASP.NET MVC Framework (MVC 5) does not have built-in support for DI, but you can still implement it using third-party dependency injection containers like:

• Unity
• Ninject
• Autofac
• StructureMap

Example with Unity:

1. Install Unity via NuGet:

   Install-Package Unity.Mvc
   

2. Configure Unity in Global.asax:

   using Unity;
   using Unity.Mvc5;
   
   public class MvcApplication : System.Web.HttpApplication
   {
       protected void Application_Start()
       {
           AreaRegistration.RegisterAllAreas();
           RouteConfig.RegisterRoutes(RouteTable.Routes);
   
           // Set up Unity container
           var container = new UnityContainer();
           container.RegisterType<StudentContext>();
           DependencyResolver.SetResolver(new UnityDependencyResolver(container));
       }
   }
   

3. Modify Controller to Use DI:

   public class HomeController : Controller
   {
       private readonly StudentContext _context;
   
       public HomeController(StudentContext context)
       {
           _context = context;
       }
   
       public ActionResult Index()
       {
           var students = _context.Students.ToList();
           return View(students);
       }
   }
   

Here, Unity takes care of creating and injecting the StudentContext instance into the HomeController.

---

What Happens When You Use DI in MVC Framework?

1. Improved Testability:

   • You can inject mocks or fakes for testing without depending on the actual implementation.

2. Separation of Concerns:

   • Your controllers don't handle object creation, making them simpler and focused on logic.

3. Lifecycle Management:

   • DI containers manage object lifetimes (singleton, transient, scoped), improving resource utilization.

4. Flexibility and Scalability:

   • Switching implementations (e.g., StudentContext to a mock context) is straightforward.

---

Summary

• DI is not limited to .NET Core; it can also be implemented in the ASP.NET MVC Framework (e.g., MVC 5) using third-party containers.
• In .NET Core, DI is built-in and easier to configure.
• In MVC Framework, you need to set up a DI container manually (e.g., Unity, Autofac).
• The benefits of DI—testability, maintainability, and flexibility—apply to both .NET Core and MVC Framework.

If you're using the MVC Framework, Unity or Autofac would be a great starting point for implementing DI. Let me know if you need help with the setup!