I’m here to discuss Dependency Injection. My approach in this blog will be slightly different from the previous one. Since Dependency Injection is a broad topic and an important concept that every developer should master, I’ve decided to write three blog posts about it for now. Eventually, if I realize that another topic related to Dependency Injection is needed, I’ll write an additional blog to cover that.
The three blog posts will focus on the following:
- A beginner’s guide – A general introduction to Dependency Injection in .NET
- Core concepts – The most important aspects of DI in .NET (in my opinion)
- Real-world application – A specific problem solved by using DI in .NET
Okay, this introduction is getting a bit long already, so let’s get started!
Why Should You Care About Dependency Injection?
When I first started working on complex .NET applications, one of the challenges I faced was managing dependencies between different components. As the project grew, the code became harder to maintain, and testing became a nightmare. That’s where DI came in and changed the game.
Dependency Injection is a design pattern that helps you achieve Inversion of Control (IoC) between classes and their dependencies. Instead of a class creating its dependencies, they’re injected from the outside. This makes your code modular, testable, and easier to maintain.
How Does Dependency Injection Work in .NET?
The basic idea behind DI in .NET is simple: instead of creating instances of services or classes inside your code, you define these dependencies externally and inject them where needed. This can be done through constructor injection, method injection, or property injection. The most common approach in .NET applications is constructor injection.
Types of Dependecy Injection
- Constructor Injection: Injects the dependency via the class constructor. It’s the most commonly used method and is ideal for mandatory dependencies.
- Method Injection: Passes the dependecy through a method. Useful when dependency is needed for a single operation rather than the whole class.
- Property Injection: Sets the dependency through a property, it’s often used when the dependency is optional.
Setting Up DI in .NET
.NET has a built-in dependency injection container, which makes it straightforward to register and resolve dependencies. To get started, you register your services during application startup, usually in the Program.cs file.
Registering Dependecies
There are three main service lifetimes you can specify when registering a dependency:
- Transient: A new instance is created every time the service is requested.
- Scoped: A new instance is created per scope (e.g. per web request in ASP.NET Core)
- Singleton: A single instance is created and shared throughout the application lifetime.
I will discuss these three service lifetimes in more detail in a future blog post.
Here’s quick example of registering services:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton<IConfiguration>(builder.Configuration);
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddTransient<INotificationService, EmailNotificationService>();
var app = builder.Build();Accessing Dependencies
You can access your registered services through dependency injection in controllers, services, or any other class where DI is supported.
public class AppointmentController : Controller {
private readonly INotificationService _notificationService;
public AppointmentController(INotificationService notificationService) {
_notificationService = notificationService;
}
public IActionResult Book(string patientName) {
_notificationService.Send($"Appointment booked for {patientName}");
return Ok();
}
}Best Practices for Using DI in .NET
- Use Interfaces for Abstraction: Always depend on abstractions rather that concrete implementations.
- Keep DI Configuration Simple: Avoid overcomplicating your DI setup. Use well-defined interfaces.
- Avoid Service Locator Pattern: Directly accessing the DI container within your classes can lead to tightly coupled code.
- Be Mindful of Service Lifetime: Choosing the wrong lifetime can lead to memory leaks or performance issues.
- Inject Only What You Need: Avoid constructor overloads with too many dependencies, as it indicates that the class has too many responsibilities.
Troubleshooting Common DI Issues
- Unable to resolve service type of XYZ: Check if you have registered the service correctly.
- Multiple constructors found: Ensure your class has only one constructor for DI
- Scope Issues in Singleton Services: Avoid injecting scoped services into singletons, as it can cause unexpected behaviors.
DI is more than just a pattern, it’s a way to make your applications scalable and maintainable. The real power of DI in .NET comes from its flexibility and the built-in container support that makes it easy to manage dependencies.
Mastering DI takes time, but once you understand the core concepts, you’ll see how it enhances your code’s modularity and testability.
