What Is Dependency Injection in ASP.NET Core?

In ASP.NET Core, Dependency Injection (DI) is a core concept that helps us manage object creation and lifetimes. In the previous section, we discussed data passing between controllers and views, along with model binding. In this section, we’ll delve deeper into what dependency injection is—and how it makes our applications more flexible and maintainable.

What Is Dependency Injection?

Dependency injection is a software design pattern that enables the development of loosely coupled applications. Instead of creating their dependencies internally, objects receive those dependencies (i.e., other required objects) as parameters—typically via constructors or properties. This approach simplifies managing relationships among objects.

ASP.NET Core includes built-in support for dependency injection, allowing seamless dependency passing across components.

Why Do We Need Dependency Injection?

Without dependency injection, classes often instantiate their own dependencies directly—a practice with several drawbacks:

1. Tight Coupling: Concrete implementations of dependencies are hardcoded inside classes, resulting in rigid inter-class dependencies. When a dependency changes, dependent classes must also be modified.

2. Difficult to Test: During unit testing, we frequently need to substitute real dependencies (e.g., database access or HTTP calls) with mock or stub objects. Without DI, such substitutions become cumbersome or impossible.

3. Poor Maintainability: As class complexity grows, so does the internal web of dependencies—making code harder to understand, modify, and extend.

How Dependency Injection Works

In ASP.NET Core, the DI workflow typically follows these steps:

1. Service Registration: Register required services in the ConfigureServices method of the Startup class (or in Program.cs for .NET 6+).
2. Service Consumption: Request services where needed—most commonly via constructor injection in controllers or other services.
3. Service Resolution: The ASP.NET Core DI container manages service lifetimes and supplies appropriate instances whenever they’re requested.

Example: Using a Service via Dependency Injection

Let’s walk through a simple example demonstrating dependency injection in action.

1. Define a Service Interface and Implementation

First, define a basic service interface IGreetingService and its implementation GreetingService.

public interface IGreetingService
{
    string Greet(string name);
}

public class GreetingService : IGreetingService
{
    public string Greet(string name)
    {
        return $"Hello, {name}!";
    }
}

2. Register the Service

Next, register the service in the ConfigureServices method of Startup.cs (or Program.cs).

public void ConfigureServices(IServiceCollection services)
{
    // Register IGreetingService as a Transient service
    services.AddTransient<IGreetingService, GreetingService>();
    
    // Other service registrations
    services.AddControllersWithViews();
}

3. Consume the Service via Dependency Injection

In a controller, inject IGreetingService via constructor injection:

public class GreetingController : Controller
{
    private readonly IGreetingService _greetingService;

    public GreetingController(IGreetingService greetingService)
    {
        _greetingService = greetingService;
    }

    public IActionResult Greet(string name)
    {
        var message = _greetingService.Greet(name);
        return Content(message);
    }
}

4. Make a Request

When you navigate to /Greeting/Greet?name=World, the controller invokes GreetingService.Greet() and returns Hello, World!. Thanks to dependency injection, the controller remains decoupled from the concrete implementation.

Summary

Dependency injection is a foundational feature of ASP.NET Core that significantly improves application manageability and testability. In this section, we covered the fundamental concepts behind DI, why it matters, and how to apply it within ASP.NET Core. By adopting DI, we enhance code reusability, simplify maintenance, and enable robust unit testing.

In the next section, we’ll explore service registration in greater depth—and examine how ASP.NET Core manages service lifetimes.