How to Use Dependency Injection in .NET Core With Practical Example?

Dependency Injection in .NET Core is a fundamental concept used to build scalable, maintainable, and testable applications. In modern ASP.NET Core Web APIs, microservices architecture, and enterprise backend systems, dependency injection (DI) is built into the framework and plays a critical role in clean architecture and loosely coupled design.

In this practical guide, we will understand what dependency injection is, why it is important in production-grade .NET applications, and how to implement it step by step using a real-world example.

What Is Dependency Injection in .NET Core?

Dependency Injection is a design pattern where a class receives its dependencies from an external source instead of creating them internally.

Without dependency injection, classes become tightly coupled, making unit testing and maintenance difficult.

In .NET Core, a built-in IoC (Inversion of Control) container automatically manages object creation and lifetime. This makes implementing dependency injection simple and consistent across ASP.NET Core applications.

Why Dependency Injection Is Important in Enterprise Applications

In production .NET backend systems, dependency injection provides:

Loose coupling between components
Easier unit testing
Better code maintainability
Improved scalability
Centralized configuration of services

In microservices and cloud-native applications, DI ensures services can evolve independently without breaking dependent components.

Types of Service Lifetimes in .NET Core

When registering services in ASP.NET Core, you must choose a lifetime.

1. Transient

A new instance is created every time the service is requested.

Used for lightweight, stateless services.

2. Scoped

A single instance is created per HTTP request.

Commonly used for database contexts in Web APIs.

3. Singleton

Only one instance is created and shared across the entire application lifetime.

Used for configuration services or caching components.

Choosing the correct lifetime is critical for performance and memory management in high-traffic production systems.

Practical Example: Implementing Dependency Injection in ASP.NET Core

Let’s build a simple example of a service that calculates discounts for an eCommerce application.

Step 1: Create a Service Interface

public interface IDiscountService
{
    decimal CalculateDiscount(decimal amount);
}

Defining an interface ensures loose coupling and improves testability.

Step 2: Implement the Service

public class DiscountService : IDiscountService
{
    public decimal CalculateDiscount(decimal amount)
    {
        return amount * 0.10m; // 10% discount
    }
}

This class contains business logic. It does not depend on controllers directly.

Step 3: Register Service in Program.cs

In ASP.NET Core, services are registered in the dependency injection container.

builder.Services.AddScoped<IDiscountService, DiscountService>();

Here, we register the service with Scoped lifetime.

Step 4: Inject Service into a Controller

[ApiController]
[Route("api/[controller]")]
public class OrderController : ControllerBase
{
    private readonly IDiscountService _discountService;

    public OrderController(IDiscountService discountService)
    {
        _discountService = discountService;
    }

    [HttpGet("calculate")]
    public IActionResult Calculate(decimal amount)
    {
        var discount = _discountService.CalculateDiscount(amount);
        return Ok(new { Discount = discount });
    }
}

The controller does not create the DiscountService manually. The .NET Core dependency injection container automatically provides it.

This approach improves maintainability and makes the controller easier to test.

Testing Benefits of Dependency Injection

Because the controller depends on an interface, you can easily mock the service in unit tests.

For example, during testing, you can inject a mock implementation instead of the real DiscountService.

This makes automated testing easier in CI/CD pipelines and enterprise DevOps workflows.

Common Mistakes to Avoid

When using dependency injection in .NET Core:

Do not register everything as Singleton without understanding lifetime implications.
Avoid injecting too many dependencies into one class.
Do not create service instances manually using new keyword.
Keep services focused on single responsibility.

Proper use of dependency injection ensures clean architecture and scalable backend systems.

Dependency Injection in Real-World ASP.NET Core Applications

In production-grade .NET applications, DI is commonly used for:

Database contexts (Entity Framework Core)
Logging services
Caching services
External API integrations
Configuration services
Authentication services

Dependency injection is the backbone of modern ASP.NET Core Web API architecture.

Summary

Dependency Injection in .NET Core is a powerful design pattern that promotes loose coupling, testability, and maintainability in modern backend applications. By defining interfaces, implementing services, registering them in the built-in dependency injection container, and injecting them into controllers or other components, developers can build scalable and production-ready ASP.NET Core applications. Understanding service lifetimes and following clean architecture principles ensures optimal performance and reliability in enterprise and cloud-native .NET systems.