Dependency Injection

Introduction

Dependency Injection (DI) is a design pattern used to implement Inversion of Control (IoC) in which dependencies are injected into a class, rather than being created by the class itself. ASP.NET Core has built-in support for DI, which makes it easier to manage dependencies.

Setting Up the Development Environment

Before you start, ensure you have the following installed:

• Visual Studio 2019 or later
• .NET Core SDK

https://dotnet.microsoft.com/download/dotnet-core

Creating a New ASP.NET Core Project

Open Visual Studio and create a new project:

• Select "Create a new project".
• Choose "ASP.NET Core Web Application" and click "Next".
• Name your project and select the location to save it. Click "Create".
• In the "Create a new ASP.NET Core Web Application" dialog, select "Web Application (Model-View-Controller)" and click "Create".

Understanding Dependency Injection

DI in ASP.NET Core allows you to manage dependencies in a more organized and flexible manner. The framework provides a built-in IoC container that can manage object lifetimes and resolve dependencies.

Service Lifetimes

ASP.NET Core supports three types of service lifetimes:

• Transient: Created each time they are requested.
• Scoped: Created once per request.
• Singleton: Created once and shared throughout the application's lifetime.

Registering Services

To use DI, you need to register services in the Startup.cs file. Here’s how you can register a simple service:

public interface IMyService
{
    void MyMethod();
}

public class MyService : IMyService
{
    public void MyMethod()
    {
        // Implementation
    }
}

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddTransient<IMyService, MyService>();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // Middleware registration
    }
}

Injecting Services

Once a service is registered, it can be injected into controllers, views, or other services. Here’s an example of injecting a service into a controller:

public class HomeController : Controller
{
    private readonly IMyService _myService;

    public HomeController(IMyService myService)
    {
        _myService = myService;
    }

    public IActionResult Index()
    {
        _myService.MyMethod();
        return View();
    }
}

Using Dependency Injection in Middleware

You can also use DI in custom middleware. Here’s an example of a custom middleware that uses DI:

public class MyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IMyService _myService;

    public MyMiddleware(RequestDelegate next, IMyService myService)
    {
        _next = next;
        _myService = myService;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        _myService.MyMethod();
        await _next(context);
    }
}

public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.UseMiddleware<MyMiddleware>();
    }
}

Service Lifetimes in Detail

Understanding the differences between service lifetimes is crucial for designing a robust application. Here’s a deeper look at each lifetime:

public void ConfigureServices(IServiceCollection services)
{
    // Transient service
    services.AddTransient<IMyTransientService, MyTransientService>();

    // Scoped service
    services.AddScoped<IMyScopedService, MyScopedService>();

    // Singleton service
    services.AddSingleton<IMySingletonService, MySingletonService>();
}

Conclusion

Congratulations! You have learned the basics of Dependency Injection in ASP.NET Core. This tutorial covered setting up a new project, registering services, injecting services into controllers and middleware, and understanding service lifetimes. From here, you can further explore more advanced topics like using third-party IoC containers, managing complex dependencies, and best practices for designing loosely coupled applications.