Dependency Injection (DI) is a design pattern that has become a staple in modern application development, including in .NET Core. It promotes the creation of modular, decoupled, and maintainable code, making your software more scalable and easier to test. With the release of .NET Core 8, DI remains a core feature, enhanced with new capabilities to further streamline development.

What is Dependency Injection?

At its core, Dependency Injection is a technique that enables an external entity, like a framework, to provide a class with its dependencies. In traditional programming, a class might create its dependencies internally, which tightly couples it to those dependencies. DI flips that by allowing the framework to “inject” those dependencies into the class from the outside.

This means a class no longer needs to know how to create the objects it depends on, leading to cleaner, more flexible, and testable code.

Why Use Dependency Injection?

Loose Coupling: Your code becomes more modular and interchangeable, as classes are less dependent on specific implementations.
Testability: It simplifies unit testing by allowing you to mock dependencies.
Maintainability: DI promotes a clean separation of concerns, making code easier to understand and modify.
Inversion of Control: DI is a form of IoC, where the control over creating and managing dependencies is shifted away from your class.

Setting Up Dependency Injection in .NET Core 8

In .NET Core, DI is configured in the Program.cs file through the built-in service container. You register your services using methods like Add{ServiceType}, where {ServiceType} represents the lifecycle of the service you want to register.

Simple Example of DI Configuration

Let’s look at an example where we inject an email service into a controller:

public interface IEmailService
{
    void SendEmail(string to, string subject, string body);
}

public class EmailService : IEmailService
{
    public void SendEmail(string to, string subject, string body)
    {
        Console.WriteLine($"Email sent to {to} with subject {subject}.");
    }
}

To register this service in the DI container, we modify the Program.cs file:

var builder = WebApplication.CreateBuilder(args);

// Register the email service
builder.Services.AddScoped<IEmailService, EmailService>();

var app = builder.Build();

Here, AddScoped ensures that the EmailService is created once per request.

Service Lifetimes in .NET Core

In .NET Core, you can register services with different lifetimes:

Transient (AddTransient): A new instance is created every time the service is requested.
Scoped (AddScoped): A single instance is created for each request (in web apps, this usually means once per HTTP request).
Singleton (AddSingleton): One instance is created and shared across the entire application's lifetime.

If you wanted the EmailService to be a singleton, the registration would look like this:

builder.Services.AddSingleton<IEmailService, EmailService>();

Injecting Dependencies

Once services are registered, you can inject them into any class that needs them. Typically, this is done via the constructor:

public class HomeController : Controller
{
    private readonly IEmailService _emailService;

    // Dependency injected via constructor
    public HomeController(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public IActionResult Index()
    {
        // Use the injected service
        _emailService.SendEmail("user@example.com", "Welcome", "Thanks for signing up!");
        return View();
    }
}

Here, the HomeController class depends on the IEmailService, which is injected into its constructor. .NET Core's DI system automatically resolves this dependency.

Advanced Dependency Injection with Multitenancy

As more applications adopt multitenancy (where a single instance serves multiple clients or tenants), .NET Core 8 has enhanced its DI support to handle different tenants using different implementations of the same service. You can now register services dynamically based on the tenant.

Example of Multitenancy

Let’s say you need to inject different email services based on the current tenant:

builder.Services.AddScoped<IEmailService>(provider =>
{
    var tenantId = provider.GetRequiredService<ITenantProvider>().TenantId;
    if (tenantId == "TenantA")
    {
        return new EmailServiceA();
    }
    else
    {
        return new EmailServiceB();
    }
});

This approach allows you to inject different implementations of IEmailService depending on the tenant, making your application highly flexible.

Best Practices for Using Dependency Injection

Avoid Singleton Services with Transient Dependencies: If a singleton service depends on a transient service, the transient service won’t be recreated, which can lead to unexpected behavior. It’s best to avoid this combination unless necessary.
Don’t Overuse DI: Injecting too many dependencies into a single class can make your code harder to manage and understand. Try to limit the number of injected services.
Optional Dependencies: Use IServiceProvider to resolve optional dependencies at runtime, but be cautious—this can make your code harder to test.

Conclusion

Dependency Injection in .NET Core 8 remains an essential tool for building scalable, maintainable, and testable applications. By leveraging DI correctly, you can create flexible architectures that are easy to extend and adapt. The framework’s enhancements, including better support for multitenancy and lifecycle management, make DI even more powerful in .NET Core 8.

Incorporating these best practices into your development process will help ensure that your applications remain maintainable, flexible, and ready to scale as your needs evolve.

Dependency Injection in .NET Core 8: Concepts and Best Practices