What is the service lifetimes in Asp.net core?

Question

Alkesh Bijarniya · Answer

Transient – created each time they’re requested from the service container Scoped – created once per client request and is reused within that request Singleton – created only once and is reused across the application’s lifetime

Rajanikant Hawaldar · Answer

Hello Naresh, Refer below articles, https://www.c-sharpcorner.com/article/service-lifetime-dependency-injection-asp-net-core/ https://www.c-sharpcorner.com/article/dependency-injection-lifetimes-in-asp-net-core/ https://www.c-sharpcorner.com/article/experimenting-with-service-lifetimes-in-net-core/

Vishal Yelve · Answer

Hi Naresh, There are three lifetimes that can be used with Microsoft Dependency Injection Container, they are: Transient — Services are created each time they are requested. It gets a new instance of the injected object, on each request of this object. For each time you inject this object is injected in the class, it will create a new instance. Scoped — Services are created on each request (once per request). This is most recommended for WEB applications. So for example, if during a request you use the same dependency injection, in many places, you will use the same instance of that object, it will make reference to the same memory allocation. Singleton — Services are created once for the lifetime of the application. It uses the same instance for the whole application. For more details please refer below links https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-6.0 https://www.c-sharpcorner.com/article/service-lifetime-dependency-injection-asp-net-core/#:~:text=There%20are%203%20types%20of,Singleton%20Service https://henriquesd.medium.com/dependency-injection-and-service-lifetimes-in-net-core-ab9189349420

Uday Dodiya · Answer

Hi Naresh, Refer This https://henriquesd.medium.com/dependency-injection-and-service-lifetimes-in-net-core-ab9189349420#:~:text=The%20service%20lifetime%20controls%20how,IServiceColletion%20when%20registering%20the%20service.%E2%80%9D

Tuhin Paul · Answer

Hello Naresh, In ASP.NET Core, the service lifetimes determine how long a particular instance of a service should be kept in memory. There are three built-in service lifetimes: Transient - Transient services are created every time they are requested. This means that a new instance of the service is created every time a component requests it. The lifetime of a transient service is typically very short, and they are generally used for lightweight, stateless services. Scoped -Scoped services are created once per client request. This means that the same instance of the service is used throughout the processing of a single client request. Scoped services are often used to maintain state across multiple calls to a service within a single client request. Singleton - A single instance of the service is created and shared across all requests. This lifetime should be used for services that are expensive to create and can be safely shared across all clients. To specify the lifetime of a service in ASP.NET Core, you can use the AddTransient, AddScoped, or AddSingleton methods when registering the service with the dependency injection container. Choosing the appropriate lifetime for a service is important because it determines how long the service instance will be kept in memory. If you choose a lifetime that is too short, such as transient, then you may end up creating unnecessary instances of the service and using up memory that could be better used elsewhere. On the other hand, if you choose a lifetime that is too long, such as singleton, then you may end up using more memory than you need to and possibly even introducing bugs into your application if the shared state of the singleton service is not properly managed. In addition to the built-in lifetimes of transient, scoped, and singleton, you can also create your own custom service lifetimes if you have specific needs for your application. For example, you may need a service that is created for the lifetime of a user session, or a service that is created for the lifetime of a particular feature in your application. In these cases, you can create a custom service lifetime that meets your specific requirements. When creating a custom service lifetime, you will typically need to implement the "IServiceScopeFactory" interface and create a new instance of "IServiceScope" for each new scope of the service. Within each scope, you can then create and manage the instances of the service as needed. By creating custom service lifetimes, you can ensure that your services are optimized for your application's specific needs, which can lead to better performance and more efficient memory usage.

Rajeev Kumar · Answer

There are three lifetimes available with the Microsoft Dependency Injection container: transient, singleton, and scoped . The lifetime of the service is specified when registering the service in the container. What is the difference between service lifetime transient and scoped? Transient services are created every time they are injected. This is the default service lifetime. Scoped services are created once per request . Singleton services are created only once, the same instance gets injected to every dependent class.