Find difference between AddTransient Vs AddSingleton Vs AddScoped in ASP.NET Core

Introduction

Hi again! After seeing the difference between value type and reference type variables, and asp.net core interview questions, we'll now find the difference between addtransient vs scoped vs singleton in ASP.net core.

Recognizing the complete life cycle of DI (Dependency Injection) is necessary in ASP.Net Core apps. As we aware, DI is a method for accomplishing loose bonding between objects and their dependencies. Generally, the classes always declare their own dependencies through the constructor, enabling them to follow the rule of Explicit Dependencies. This process is known as constructor injection.

In order to apply dependency injection, we should configure a specific DI container with predetermined classes that are contributing to DI.

Why we need to learn this difference?

• It explains the lifetime of object composition or a registration in the .net core with the assistance of Dependency Injection (DI).
• Then, DI Container has to determine whether to return a new service instance or deliver a present object or instance
• The Service duration, depends on how we initiate the dependency.
• We explain the lifetime while we get the service registered.
  

The following 3 options of lifetime and registration are explained.

1. AddScoped

Scoped lifetime services are developed only once per request. In scoped service, we receive a new object or instance with each single HTTP request. A similar instance is delivered for the whole scope of the same request.

For example, if we have some parameters in the regulator, both object possesses the same instance for the request

This is definitely a better option when you wish to maintain a state within a request.

services.AddScoped<IAuthService,AuthService>();

2. AddSingleton

Singleton lifetime services are automatically developed the 1st time they are requested (or while ‘ConfigureServices' is run if you mention an object or instance there and then each successive request will utilize the same object or instance.

• Only one service object or instance was developed throughout the lifetime.
•  Wherever the service is needed, the same object or instance is frequently utilized.
• Since its generation of a single lifetime service, memory gets leaked in these services will increase over time.
• Also, it possesses a memory efficiency as they are developed once reutilized everywhere.

services.AddSingleton<ILoggingService, LoggingService>();

3. AddTransient

Transient lifetime services are automatically developed every time they receive an http request. This transient lifetime works adequately for stateless services that are lightweight.

• Against every single object or instance in the HTTP request, a new single service instance is generated.
• This is the right method for the multi-threading technique as both objects are independent of each other.
• The instance is generated every time they will get utilized more memory and resources and can get an adverse effect on performance.
• This is utilized for lightweight service that is little or has no state.

services.AddTransient<ICronJobService, CronJobService>();

Which Service is used when?

In order to understand addtransient vs scoped vs singleton, following are the utility of 3 methods.

AddSingleton method: This can be used for logging service, deployment feature flag (to on and off the module at the time of deployment), email service, and many more.

AddScoped method: This is a better choice if you wish to maintain a state within a request.

AddTransient method: This method is used for lightweight as well as stateless service.

Conclusion

I hope you got a detailed idea about addtransient vs scoped vs singleton from this article. Mostly, the ASP.net developers could get enough idea about dependency injection.