How Do You Implement Dependency Injection in .NET 7

Check out this article:

https://www.c-sharpcorner.com/article/dependency-injection-made-simple-a-practical-net-core-guide/

Wondering why you are stuck in .NET 7.0 !!!! .NET 10.0 already generally available :)

Dependency Injection in .NET 7 is implemented using the built-in DI container provided by the framework. You register services in the Program.cs file using methods like AddTransient, AddScoped, or AddSingleton, and then inject them into controllers or classes via constructor injection to promote loose coupling, testability, and maintainable code.

Dependency Injection (DI) is a design pattern that allows a class to receive its dependencies from the outside rather than creating them internally. This makes your code more maintainable, testable, and loosely coupled. In .NET 7, DI is built into the framework, especially in ASP.NET Core.

There are three main lifetimes for services in .NET:

• Transient: a new instance is created every time it is requested.

• Scoped: a single instance is created per HTTP request.

• Singleton: a single instance is shared across the entire application.

Step 1: Define an interface and implementation

public interface IMessageService
{
    string GetMessage();
}

public class MessageService : IMessageService
{
    public string GetMessage()
    {
        return "Hello from MessageService!";
    }
}

Step 2: Register the service in Program.cs

In .NET 7, Program.cs replaces the older Startup.cs file. You register services using builder.Services:

var builder = WebApplication.CreateBuilder(args);

// Register the service with a transient lifetime
builder.Services.AddTransient();

var app = builder.Build();

app.MapGet("/", (IMessageService messageService) =>
{
    return messageService.GetMessage();
});

app.Run();

Here, AddTransient() tells the DI container to provide a new MessageService instance whenever IMessageService is requested. Minimal APIs automatically inject the service into route handlers.

Step 3: Injecting into Controllers

For an ASP.NET Core API controller, you use constructor injection:

[ApiController]
[Route("[controller]")]
public class HelloController : ControllerBase
{
    private readonly IMessageService _messageService;

    public HelloController(IMessageService messageService)
    {
        _messageService = messageService;
    }

    [HttpGet]
    public IActionResult GetMessage()
    {
        return Ok(_messageService.GetMessage());
    }
}

Step 4: Register services with different lifetimes

builder.Services.AddTransient(); // new instance each time
builder.Services.AddScoped();       // per HTTP request
builder.Services.AddSingleton(); // one instance for app lifetime

Step 5: Injecting multiple implementations

builder.Services.AddTransient();
builder.Services.AddTransient();

public class NotificationController
{
    private readonly IEnumerable _services;

    public NotificationController(IEnumerable services)
    {
        _services = services;
    }
}

.NET automatically injects all registered implementations into IEnumerable.

.NET 7 comes with built-in DI, constructor injection is preferred, pick the appropriate service lifetime, and DI works in minimal APIs, controllers, middleware, and background services.

Benefits of using Dependency Injection (DI) framework:

1. Loose Coupling
By using DI, classes don’t create their own dependencies. They rely on abstractions (interfaces), which makes it easier to swap implementations without changing dependent code.

• Example: You can switch from EmailService to SmsService without modifying the consumer class.

2. Easier Testing
DI frameworks make unit testing simpler because you can inject mock or fake dependencies into classes.

• Example: Instead of sending real emails in tests, you inject a MockEmailService.

3. Centralized Configuration
All dependencies are registered in one place (like Program.cs in .NET 7).

• This makes it easy to see what services exist and manage their lifetimes (Transient, Scoped, Singleton) consistently.

4. Lifetime Management
DI frameworks automatically handle object lifetimes, so you don’t need to manually manage singletons, scoped objects, or transient objects.

• Example: In ASP.NET Core, a repository can be a singleton while a service is transient, all managed automatically.

5. Scalability & Maintainability
As your application grows, DI keeps the code modular and maintainable. Adding new services or replacing existing ones becomes simpler without touching other parts of the system.

6. Promotes Interface-Driven Design
DI encourages coding against interfaces instead of concrete classes. This improves code clarity, flexibility, and adherence to SOLID principles, especially the Dependency Inversion Principle.

7. Supports Cross-Cutting Concerns
With DI frameworks, it’s easy to integrate cross-cutting concerns like logging, caching, and authentication by injecting shared services where needed.

8. Reduces Boilerplate Code
Without DI, you often have to manually instantiate dependencies and pass them through multiple constructors. DI frameworks handle this automatically, reducing repetitive code.

9. Runtime Flexibility
Some DI frameworks allow conditional or dynamic resolution of services at runtime.

• Example: Choosing different implementations based on configuration or environment.

Dependency Injection in ASP.NET Core means passing required services to a class instead of creating them inside it,

for example

public HomeController(IEmailService emailService)

{

_emailService = emailService;

}

This makes the code loosely coupled, easier to test, and easier to maintain.

Dependency Injection helps remove tight coupling by injecting services through the constructor.

builder.Services.AddScoped();

It makes unit testing easy by allowing mock implementations.

var controller = new HomeController(new FakeService());

ASP.NET Core has built-in DI, so no external framework is required.

public HomeController(ILogger logger)

DI improves maintainability by separating service creation from business logic.