Understanding AddTransient Vs AddScoped Vs AddSingleton In ASP.NET Core

Introduction

Understanding the life cycle of Dependency Injection (DI) is very important in ASP.Net Core applications. As we know, Dependency injection (DI) is a technique for achieving loose coupling between objects and their collaborators, or dependencies. Most often, classes will declare their dependencies via their constructor, allowing them to follow the Explicit Dependencies Principle. This approach is known as "constructor injection".

To implement dependency injection, we need to configure a DI container with classes that is participating in DI. DI Container has to decide whether to return a new instance of the service or provide an existing instance. In startup class, we perform this activity on ConfigureServices method.

The lifetime of the service depends on when the dependency is instantiated and how long it lives. And lifetime depends on how we have registered those services.

The below three methods define the lifetime of the services,

1. AddTransient: Transient lifetime services are created each time they are requested. This lifetime works best for lightweight, stateless services.
2. AddScoped: Scoped lifetime services are created once per request.
3. AddSingleton: Singleton lifetime services are created the first time they are requested (or when ConfigureServices is run if you specify an instance there) and then every subsequent request will use the same instance.

Understanding Dependency Injection Lifetime with an Example

Let’s understand DI lifetime with an example in a sample ASP.NET core application.

In my sample project, I added three interfaces called – ItransientService, IScopedService, ISingletonService, which represents one of each of the DI lifetimes. Those interfaces contain a single method called GetOperationID(); which will return a uniqueGuid.

using System;    
namespace TransientScopedSingleton {    
    publicinterfaceITransientService {    
        Guid GetOperationID();    
    }    
}

using System;  
namespace TransientScopedSingleton {  
    publicinterfaceIScopedService {  
        Guid GetOperationID();  
    }  
}

using System;    
namespace TransientScopedSingleton {    
    publicinterfaceISingletonService {    
        Guid GetOperationID();    
    }    
}

Let’s implement those 3 interfaces into a service called OperationService.

using System;  
namespace TransientScopedSingleton {  
    publicclassOperationService: ITransientService,  
    IScopedService,  
    ISingletonService {  
        Guid id;  
        publicOperationService() {  
            id = Guid.NewGuid();  
        }  
        public Guid GetOperationID() {  
            return id;  
        }  
    }  
}

Now, register the OperationService via those three interfaces as shown below in the ConfigureServices method of the startup class.

services.AddTransient<ITransientService, OperationService>();    
services.AddScoped<IScopedService, OperationService>();    
services.AddSingleton<ISingletonService, OperationService>();

Awesome! Now we are ready to inject those services into controller. For better understanding, we will inject two instances of each service in the constructor of HomeController.

private readonly ILogger<HomeController> _logger;    
private readonly ITransientService _transientService1;    
private readonly ITransientService _transientService2;    
private readonly IScopedService _scopedService1;    
private readonly IScopedService _scopedService2;    
private readonly ISingletonService _singletonService1;    
private readonly ISingletonService _singletonService2;    
    
public HomeController(ILogger<HomeController> logger,     
            ITransientService transientService1,    
            ITransientService transientService2,    
            IScopedService scopedService1,    
            IScopedService scopedService2,    
            ISingletonService singletonService1,    
            ISingletonService singletonService2)    
{    
    _logger = logger;    
    _transientService1 = transientService1;    
    _transientService2 = transientService2;    
    _scopedService1 = scopedService1;    
    _scopedService2 = scopedService2;    
    _singletonService1 = singletonService1;    
    _singletonService2 = singletonService2;    
}

Now we will call GetOperationID method of each service instance and assign it to viewbag so that we can see those values in UI.

public IActionResult Index()  
{  
    ViewBag.transient1 = _transientService1.GetOperationID().ToString();  
    ViewBag.transient2 = _transientService2.GetOperationID().ToString();  
    ViewBag.scoped1 = _scopedService1.GetOperationID().ToString();  
    ViewBag.scoped2 =  _scopedService2.GetOperationID().ToString();  
    ViewBag.singleton1 = _singletonService1.GetOperationID().ToString();  
    ViewBag.singleton2 = _singletonService2.GetOperationID().ToString();  
    return View();  
}