ASP.net Core Services Lifetime Differences Between Using AddTransient, AddScoped and AddSingleton Services
ASP.net Core
Services Lifetime Differences Between Using AddTransient, AddScoped and AddSingleton
Services
Overview
In this blog post, I will be explaining to you the ASP.net
core Service Lifetime and will be explaining to you what is the difference
between them and which one can be a risk to a memory leak if used incorrectly.
AddTransient, AddScoped, and AddSingleton are dependency
injection services in ASP.NET Core. The differences between them are as follows
below.
- AddTransient: A new instance of the service is created every time it is requested.
- AddScoped: A single instance of the service is created per request within the same scope.
- AddSingleton: A single instance of the service is created for the entire application lifetime.
How to Use AddTransient, AddScoped, and AddSingleton
Below are some general guidelines on when to use each of the
AddTransient, AddScoped, and AddSingleton services in ASP.NET Core in the
program.cs file after the var builder = WebApplication.CreateBuilder(args); if using .net 6 and above for the .net 5 and
below it is in StartUp.cs with in the public void
ConfigureServices(IServiceCollection services).
- AddTransient: Use AddTransient when you need a new instance of the service each time it's requested. This is useful for services that are lightweight and stateless, such as those used for logging or for sending emails. Use AddTransient for services that are stateless, lightweight, and have a short lifetime. Examples include services that generate data, perform calculations, or interact with external APIs.
- AddScoped: Use AddScoped when you want a single instance of the service to be shared within a single request. This is useful for services that are stateful, such as those that hold data specific to the current request. Use AddScoped for services that have a request-level lifetime and maintain some state. Examples include services that access the database, perform caching, or maintain user-specific data
- AddSingleton: Use AddSingleton when you want a single instance of the service to be shared throughout the entire application. This is useful for services that are expensive to create or that need to maintain the state between requests, such as those used for caching. Use AddSingleton for services that have a singleton lifetime and are used throughout the application. Examples include services that provide global application configuration, logging, or singleton services that must only be instantiated once.
Recommend Way, You should aim to use AddTransient and
AddScoped services as much as possible, and reserve AddSingleton for services
that need to maintain state or that are expensive to create. By using the
appropriate service lifetime, you can improve the performance and scalability
of your application.
It's important to understand that
using AddSingleton can introduce potential memory leaks and synchronization
issues if not used correctly, as the same instance is shared across all
requests.
Reminder, it's recommended to choose the lifetime
based on the requirements of your service and the desired behavior of your
application.
Code Examples
In the code examples below I have given you examples of how
to use the AddSingleton, AddTransient and AddScoped and explained what each one of them means and when it's best to use them.
AddSingleton creates a single instance of a
service that is shared by all consumers throughout the application's lifetime.
Use AddSingleton when you want to create a single instance of a service that is
shared across the entire application.
builder.Services.AddSingleton<IExampleSingletonService, ExampleSingletonService>();
(.Net 6 and above)
services.AddSingleton< IExampleSingletonService, ExampleSingletonService
>(); (.Net 5 and below)
AddTransient creates a new instance of a service every time
it is requested. Use AddTransient when you want to create a new instance of a
service every time it is requested.
builder.Services. AddTransient<IExampleTransientService, ExampleTransientService>();
(.Net 6 and above)
services.AddTransient<IExampleTransientService, ExampleTransientService>();
(.Net 5 and below)
builder.Services.AddScoped<IExampleScopedService, ExampleScopedService>();
(.Net 6 and above)
services.AddScoped<IExampleScopedService, ExampleScopedService>();
(.Net 5 and below)
Final Thoughts
In this blog post I have explained about AddSingleton,
AddTransient and AddScoped and when to use each one of them and also have shared
code sample of using AddSingleton, AddTransient and AddScoped. I have point out
the riskes of using AddSingleton and reminded you about using AddSingleton,
AddTransient and AddScoped based on your development of the application needs
also I have recommended why to use AddTransient and AddScoped.
Comments