What is Dependency Injection in ASP.NET Core MVC

  What is Dependency Injection (DI)?

Dependency Injection (DI) is a design pattern used to manage dependencies between different parts of your application.

A dependency is simply an object that another object relies on to do its job.

DI is a way to provide those dependencies from the outside, rather than letting a class create them internally.

🤔 Why Use DI?

Without DI:

public class HomeController

{

    private TimeService _timeService = new TimeService(); // tightly coupled

    public string GetTime()

    {

        return _timeService.GetCurrentTime();

    }

}

❌ The controller is directly creating the dependency.

❌ Hard to test (can’t easily replace TimeService with a mock).

❌ If the implementation changes, you have to change the controller code.

public class HomeController

{

    private readonly ITimeService _timeService;

    public HomeController(ITimeService timeService)

    {

        _timeService = timeService;

    }

}

✅ TimeService is injected from outside.

✅ Easily replaceable with a mock or a new implementation.

✅ Controller is only dependent on interface, not implementation.

✅ Promotes loose coupling and separation of concerns.

🧪 Real-World Example

Imagine you're ordering pizza at a restaurant:

You (Controller) want a pizza.

The Pizza (Dependency) is made by a chef.

Without DI: You walk into the kitchen and make it yourself. 🍕❌

With DI: You just request the pizza, and someone delivers it to you, already made. 🍕✅

That someone is the Dependency Injection Container.

⚙️ How It Works in ASP.NET Core

ASP.NET Core has built-in support for DI, using a central Service Container.

Step 1:

Register Services in Program.cs

builder.Services.AddScoped<ITimeService, TimeService>();

Inject Services in constructors

public HomeController(ITimeService timeService)

Framework Resolves Dependencies automatically when creating controllers, middleware, etc.

✅ Scenario:

We want to create a service that returns the current time and display it in a controller.

📁 Step-by-step Code Example

1. Create the Interface

// Services/ITimeService.cs

public interface ITimeService

{

    string GetCurrentTime();

}

2. Create the Service Implementation

// Services/TimeService.cs

public class TimeService : ITimeService

{

    public string GetCurrentTime()

    {

        return DateTime.Now.ToString("hh:mm:ss tt");

    }

}

3. Register the Service in Program.cs

This tells ASP.NET Core to inject ITimeService wherever it's needed.

// Program.cs (ASP.NET Core 6 or later)

var builder = WebApplication.CreateBuilder(args);

// Register the service for DI (Scoped/Transient/Singleton based on need)

builder.Services.AddTransient<ITimeService, TimeService>();

builder.Services.AddControllersWithViews();

var app = builder.Build();

app.UseStaticFiles();

app.UseRouting();

app.MapDefaultControllerRoute();

app.Run();

4. Inject Service into Controller

// Controllers/HomeController.cs

using Microsoft.AspNetCore.Mvc;

using YourNamespace.Services; // Replace with actual namespace

public class HomeController : Controller

{

    private readonly ITimeService _timeService;

    // Constructor Injection

    public HomeController(ITimeService timeService)

    {

        _timeService = timeService;

    }

    public IActionResult Index()

    {

        ViewBag.CurrentTime = _timeService.GetCurrentTime();

        return View();

    }

}

5. Display Time in the View

@* Views/Home/Index.cshtml *@

<h2>Current Time from DI Service:</h2>

<p>@ViewBag.CurrentTime</p>

🎉 Output:

When you run the app and open the homepage, it will show:

Current Time from DI Service:

04:18:52 PM