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.

You may also like...