Addtransient Vs Addscoped Vs Addsingleton in .NET Core

Asp.Net Core is a free open-source platform that was developed by Microsoft along with .net core is a cross-platform that supports all most operating systems like macOS, Windows, and Linux.Asp.Net Core is a great platform embedded with a lot's of characteristics which helps build cloud-based application, device applications .Net Core can operate on Mac operating system also.

Transient services: The object of these services have created new every time a controller or service class is called or executed. ex: let's consider a request is made to a Web API controller method 'controller' as a transient after that the request will be assigned a unique id, now from inside that controller the request is redirected to other controller method go for further execution, the same request-id will be replaced with a new request-id. Singleton service: The object of this service is created once initially and does not modification for any number of requests, regardless of whether an instance is provided in ConfigureServices. For Ex: in the example doesn't matter how many time redirects happen within the web application or new requests are made to the application the id remains the same for all. Scoped service: All The objects of this service are similar within the all requests and changes with new requests.

This is a lifetime service and that was created each and every time they are requested. it provides the best lightweight, stateless services.

public void ConfigureServices(IServiceCollection services)
	        {
	services.AddControllersWithViews();
	services.AddMvc();
	services.AddTransient();
	        }

AddTransient would be used when the component cannot be shared. A non-thread-safe database use object would be one example. Transient services are a default. Constantly re-creating services reduces the risk of a broken implementation conduct everything down, since every new instance will be created in a non-broken state.

Let's take an example. just think we have one database operation where we need to insert a date into a database table and after successful insertion, you need to perform some other operation like in our case we want to insert an image into an azure blob at that time, if inserting into azure blob storage fails we have to delete the record from the database for consistency in the database. For that scenarios, we can use transactions.

AddScoped can be used for Entity Framework database contexts. The main reason is that then entities gotten from the DB will be attached to the same context and all components in the request see. If we plan on doing queries with this in side by side, you can't use Add Scoped.

Usually, we can use scoped services to make sure some processing is done only one time per request. At our current job, we use them to fetch once per request, and then that service is reuse at multiple points in the project code (e.g. In this repository for using the database, some HTTP-client accessing a back-end service) which are all transient. AddScoped: The AddScoped service is a lifetime service that was created once per request.

using System;  
namespace DemoTransientScopedSingleton {  
    public interfaceIScopedService {  
GuidGetOperationId();  
    }  
} 

public void ConfigureServices(IServiceCollection services)
        {
services.AddControllersWithViews();
services.AddMvc();
services.AddScoped();
        }

When we register a new type as a singleton, at that time only one instance is available throughout the application and for all requests.

In AddSingleton service is created instance for the first request and the same is available using the application and for each subsequent request.

public void ConfigureServices(IServiceCollection services){
services.AddSingleton()
}

An AddSingleton service was created when that is first requested. AddSingleton service, there is only the same instance. An instance is created, when service is first requested and that single instance will be used by all subsequent HTTP requests using the application.

Memory leaks in these services will build up more time. Also, memory more powerful as they are created once reused everywhere. Use Singletons where you need to maintain application full state. project configuration or parameters, Logging Service, caching of project data is some of the examples where you can use singletons.

ASP.NET core provides the 3 methods to register services with the dependency injection in container.

 

Basic Different

Singleton is a onetime instance for the lifetime of the project domain.Scoped is a one instance for the duration of the scoped request, which means per HTTP request in ASP.NET.Transient is a onetime instance per code request

AddTransient objects is always different; a new instance is provided to every controller and each service.

AddScoped objects is the same inside a request and also different across different requests.

AddSingleton objects is the same for all object and all request