Understanding Inversion of Control (IoC) Container and Lifetime Management in ASP.NET Core

In modern software development, the Inversion of Control (IoC) pattern has become a fundamental principle for building scalable and maintainable applications. The IoC pattern promotes loose coupling between classes by allowing the control of object creation and dependency resolution to be inverted or delegated to a container. In the context of ASP.NET Core, the IoC container is a core component that manages the lifetime and resolution of dependencies, making it easier to manage application dependencies and promote modular design.

In this blog post, we will explore the concept of the IoC container and understand the different dependency lifetimes supported by ASP.NET Core, accompanied by relevant code examples.

What is an IoC Container?

At its core, an IoC container is a tool that automates the process of managing object creation and dependency resolution in an application. It is responsible for instantiating objects and resolving their dependencies, removing the burden from the application code. By using an IoC container, classes can be decoupled from their dependencies, leading to more modular and testable code.

In ASP.NET Core, the built-in IoC container is based on the Microsoft.Extensions.DependencyInjection library. It is a lightweight, extensible, and feature-rich container that simplifies the management of application dependencies.

Dependency Lifetimes in ASP.NET Core

When registering services with the IoC container, you can specify different dependency lifetimes. The dependency lifetime defines how long an object (service) should exist within the container and when a new instance should be created. ASP.NET Core supports three main dependency lifetimes:

1. Transient: A new instance of the service is created every time it is requested from the container. Transient lifetime is suitable for lightweight, stateless services.
2. Scoped: A single instance of the service is created per HTTP request or service scope. Within the same HTTP request or service scope, the same instance is reused. Scoped lifetime is suitable for services that maintain state across multiple related operations within the same request.
3. Singleton: A single instance of the service is created and shared across the entire application. The same instance is reused for every request. Singleton lifetime is suitable for services that are stateless or should maintain global state throughout the application’s lifetime.

Example: Registering Services with Dependency Lifetimes

Let’s look at a practical example of registering services with different dependency lifetimes in an ASP.NET Core application:

// Startup.cs

using Microsoft.Extensions.DependencyInjection;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Transient lifetime - A new instance is created each time it's requested.
        services.AddTransient<IMyTransientService, MyTransientService>();

        // Scoped lifetime - A single instance is created per HTTP request or service scope.
        services.AddScoped<IMyScopedService, MyScopedService>();

        // Singleton lifetime - A single instance is created and shared across the application.
        services.AddSingleton<IMySingletonService, MySingletonService>();
    }
}

In this example, we have registered three services with different dependency lifetimes. Now, let’s define these services:

// Services

public interface IMyTransientService
{
    string GetInstanceId();
}

public class MyTransientService : IMyTransientService
{
    private readonly Guid _instanceId;

    public MyTransientService()
    {
        _instanceId = Guid.NewGuid();
    }

    public string GetInstanceId()
    {
        return _instanceId.ToString();
    }
}

public interface IMyScopedService
{
    string GetInstanceId();
}

public class MyScopedService : IMyScopedService
{
    private readonly Guid _instanceId;

    public MyScopedService()
    {
        _instanceId = Guid.NewGuid();
    }

    public string GetInstanceId()
    {
        return _instanceId.ToString();
    }
}

public interface IMySingletonService
{
    string GetInstanceId();
}

public class MySingletonService : IMySingletonService
{
    private readonly Guid _instanceId;

    public MySingletonService()
    {
        _instanceId = Guid.NewGuid();
    }

    public string GetInstanceId()
    {
        return _instanceId.ToString();
    }
}

In this example, we have defined three services: MyTransientService, MyScopedService, and MySingletonService, each implementing their respective interfaces. Each service has a unique identifier generated during its instantiation.

Using Services with Different Dependency Lifetimes

Now, let’s use these services in a controller to observe how their dependency lifetimes behave:

// MyController.cs

using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class MyController : ControllerBase
{
    private readonly IMyTransientService _transientService;
    private readonly IMyScopedService _scopedService;
    private readonly IMySingletonService _singletonService;

    public MyController(
        IMyTransientService transientService,
        IMyScopedService scopedService,
        IMySingletonService singletonService)
    {
        _transientService = transientService;
        _scopedService = scopedService;
        _singletonService

 = singletonService;
    }

    [HttpGet]
    public IActionResult Get()
    {
        var result = new
        {
            TransientInstanceId = _transientService.GetInstanceId(),
            ScopedInstanceId = _scopedService.GetInstanceId(),
            SingletonInstanceId = _singletonService.GetInstanceId()
        };
        return Ok(result);
    }
}

In this controller, we inject the three services as constructor parameters. We then call the GetInstanceId() method on each service and return the unique instance IDs in the HTTP response.

Conclusion

Understanding the concept of an IoC container and the different dependency lifetimes in ASP.NET Core is crucial for building modular and maintainable applications. By leveraging the IoC container, you can achieve loose coupling, improve testability, and promote good software design practices. Utilizing the appropriate dependency lifetime for each service ensures that your application performs efficiently and meets the requirements of different scenarios.

In this blog post, we explored the IoC container and the three main dependency lifetimes supported by ASP.NET Core. By applying these concepts and principles in your projects, you can create robust, scalable, and maintainable software solutions.

Remember, the IoC container is an indispensable tool in the arsenal of every software developer, enabling them to write cleaner, more modular code that is easier to maintain and extend. Embrace the IoC pattern, harness the power of the ASP.NET Core IoC container, and elevate your software development journey to new heights!

Please find original article here,  IoC Container and Lifetime Management