What is the service lifetimes in Asp.net core?

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.

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.