AddTransient AddScoped and AddSingleton Services Differences

Question

I want to implement dependency injection  DI  in ASP NET Core  So after adding this code to ConfigureServices method  both ways work   What is the difference between the services AddTransient and service AddScoped methods in ASP NET Core   public void ConfigureServices IServiceCollection services           Add framework services          Add application services      services AddTransient lt IEmailSender  AuthMessageSender gt         services AddScoped lt IEmailSender  AuthMessageSender gt

User · Answer

Which one to use Transient  since they are created every time they will use more memory  amp  Resources and can have the negative impact on performance use this for the lightweight service with little or no state   Scoped  better option when you want to maintain state within a request   Singleton  memory leaks in these services will build up over time  also memory efficient as they are created once reused everywhere   Use Singletons where you need to maintain application wide state  Application configuration or parameters  Logging Service  caching of data is some of the examples where you can use singletons  Injecting service with different lifetimes into another  Never inject Scoped  amp  Transient services into Singleton service    This effectively converts the transient or scoped service into the singleton   Never inject Transient services into scoped service   This converts the transient service into the scoped

User · Answer

Transient  scoped and singleton define object creation process in ASP NET MVC core DI when multiple objects of the same type have to be injected  In case you are new to dependency injection you can see this DI IoC video   You can see the below controller code in which I have requested two instances of  IDal  in the constructor  Transient  Scoped and Singleton define if the same instance will be injected in   dal  and   dal1  or different   public class CustomerController   Controller       IDal dal   null       public CustomerController IDal  dal                                IDal  dal1                dal    dal             DI of MVC core            inversion of control           Transient  In transient  new object instances will be injected in a single request and response  Below is a snapshot image where I displayed GUID values     Scoped  In scoped  the same object instance will be injected in a single request and response     Singleton  In singleton  the same object will be injected across all requests and responses  In this case one global instance of the object will be created   Below is a simple diagram which explains the above fundamental visually     The above image was drawn by the SBSS team when I was taking ASP NET MVC training in Mumbai  A big thanks goes to the SBSS team for creating the above image

User · Answer

After looking for an answer for this question I found a brilliant explanation with an example that I would like to share with you  You can watch a video that demonstrate the differences HERE In this example we have this given code  public interface IEmployeeRepository       IEnumerable lt Employee gt  GetAllEmployees        Employee Add Employee employee      public class Employee       public int Id   get  set        public string Name   get  set       public class MockEmployeeRepository   IEmployeeRepository       private List lt Employee gt   employeeList       public MockEmployeeRepository                  employeeList   new List lt Employee gt                  new Employee     Id   1  Name    quot Mary quot             new Employee     Id   2  Name    quot John quot             new Employee     Id   3  Name    quot Sam quot                       public Employee Add Employee employee                employee Id    employeeList Max e   gt  e Id    1           employeeList Add employee           return employee             public IEnumerable lt Employee gt  GetAllEmployees                 return  employeeList           HomeController public class HomeController   Controller       private IEmployeeRepository  employeeRepository       public HomeController IEmployeeRepository employeeRepository                 employeeRepository   employeeRepository              HttpGet      public ViewResult Create                 return View                HttpPost      public IActionResult Create Employee employee                if  ModelState IsValid                        Employee newEmployee    employeeRepository Add employee                      return View             Create View  model Employee  inject IEmployeeRepository empRepository   lt form asp-controller  quot home quot  asp-action  quot create quot  method  quot post quot  gt       lt div gt           lt label asp-for  quot Name quot  gt  lt  label gt           lt div gt               lt input asp-for  quot Name quot  gt           lt  div gt       lt  div gt        lt div gt           lt button type  quot submit quot  gt Create lt  button gt       lt  div gt        lt div gt          Total Employees Count    empRepository GetAllEmployees   Count   ToString        lt  div gt   lt  form gt   Startup cs public void ConfigureServices IServiceCollection services        services AddMvc        services AddSingleton lt IEmployeeRepository  MockEmployeeRepository gt        Copy-paste this code and press on the create button in the view and switch between AddSingleton   AddScoped and AddTransient you will get each time a different result that will might help you understand this   AddSingleton   - As the name implies  AddSingleton   method creates a Singleton service  A Singleton service is created when it is first requested  This same instance is then used by all the subsequent requests  So in general  a Singleton service is created only one time per application and that single instance is used throughout the application life time  AddTransient   - This method creates a Transient service  A new instance of a Transient service is created each time it is requested  AddScoped   - This method creates a Scoped service  A new instance of a Scoped service is created once per request within the scope  For example  in a web application it creates 1 instance per each http request but uses the same instance in the other calls within that same web request

User · Answer

This image illustrates this concept well  Unfortunately  I could not find the original source of this image  but someone made it  he has shown this concept very well in the form of an image

User · Answer

In  NET s dependency injection there are three major lifetimes   Singleton which creates a single instance throughout the application  It creates the instance for the first time and reuses the same object in the all calls   Scoped lifetime services are created once per request within the scope  It is equivalent to a singleton in the current scope  For example  in MVC it creates one instance for each HTTP request  but it uses the same instance in the other calls within the same web request   Transient lifetime services are created each time they are requested  This lifetime works best for lightweight  stateless services   Here you can find and examples to see the difference   ASP NET 5 MVC6 Dependency Injection in 6 Steps  web archive link due to dead link   Your Dependency Injection ready ASP NET   ASP NET 5  And this is the link to the official documentation   Dependency injection in ASP NET Core

User · Answer

TL DR  Transient objects are always different  a new instance is provided to every controller and every service  Scoped objects are the same within a request  but different across different requests  Singleton objects are the same for every object and every request   For more clarification  this example from  NET documentation shows the difference  To demonstrate the difference between these lifetime and registration options  consider a simple interface that represents one or more tasks as an operation with a unique identifier  OperationId  Depending on how we configure the lifetime for this service  the container will provide either the same or different instances of the service to the requesting class  To make it clear which lifetime is being requested  we will create one type per lifetime option  using System   namespace DependencyInjectionSample Interfaces       public interface IOperation               Guid OperationId   get               public interface IOperationTransient   IOperation                  public interface IOperationScoped   IOperation                  public interface IOperationSingleton   IOperation                  public interface IOperationSingletonInstance   IOperation                We implement these interfaces using a single class  Operation  that accepts a GUID in its constructor  or uses a new GUID if none is provided  using System  using DependencyInjectionSample Interfaces  namespace DependencyInjectionSample Classes       public class Operation   IOperationTransient  IOperationScoped  IOperationSingleton  IOperationSingletonInstance               Guid  guid          public Operation     this Guid NewGuid                                  public Operation Guid guid                         guid   guid                     public Guid OperationId   gt   guid           Next  in ConfigureServices  each type is added to the container according to its named lifetime  services AddTransient lt IOperationTransient  Operation gt     services AddScoped lt IOperationScoped  Operation gt     services AddSingleton lt IOperationSingleton  Operation gt     services AddSingleton lt IOperationSingletonInstance gt  new Operation Guid Empty    services AddTransient lt OperationService  OperationService gt      Note that the IOperationSingletonInstance service is using a specific instance with a known ID of Guid Empty  so it will be clear when this type is in use  We have also registered an OperationService that depends on each of the other Operation types  so that it will be clear within a request whether this service is getting the same instance as the controller  or a new one  for each operation type  All this service does is expose its dependencies as properties  so they can be displayed in the view  using DependencyInjectionSample Interfaces   namespace DependencyInjectionSample Services       public class OperationService               public IOperationTransient TransientOperation   get            public IOperationScoped ScopedOperation   get            public IOperationSingleton SingletonOperation   get            public IOperationSingletonInstance SingletonInstanceOperation   get             public OperationService IOperationTransient transientOperation              IOperationScoped scopedOperation              IOperationSingleton singletonOperation              IOperationSingletonInstance instanceOperation                        TransientOperation   transientOperation              ScopedOperation   scopedOperation              SingletonOperation   singletonOperation              SingletonInstanceOperation   instanceOperation                     To demonstrate the object lifetimes within and between separate individual requests to the application  the sample includes an OperationsController that requests each kind of IOperation type as well as an OperationService  The Index action then displays all of the controller   s and service   s OperationId values  using DependencyInjectionSample Interfaces  using DependencyInjectionSample Services  using Microsoft AspNetCore Mvc   namespace DependencyInjectionSample Controllers       public class OperationsController   Controller               private readonly OperationService  operationService          private readonly IOperationTransient  transientOperation          private readonly IOperationScoped  scopedOperation          private readonly IOperationSingleton  singletonOperation          private readonly IOperationSingletonInstance  singletonInstanceOperation           public OperationsController OperationService operationService              IOperationTransient transientOperation              IOperationScoped scopedOperation              IOperationSingleton singletonOperation              IOperationSingletonInstance singletonInstanceOperation                         operationService   operationService               transientOperation   transientOperation               scopedOperation   scopedOperation               singletonOperation   singletonOperation               singletonInstanceOperation   singletonInstanceOperation                     public IActionResult Index                            ViewBag contains controller-requested services             ViewBag Transient    transientOperation              ViewBag Scoped    scopedOperation              ViewBag Singleton    singletonOperation              ViewBag SingletonInstance    singletonInstanceOperation                  Operation service has its own requested services             ViewBag Service    operationService              return View                       Now two separate requests are made to this controller action    Observe which of the OperationId values varies within a request  and between requests   Transient objects are always different  a new instance is provided to every controller and every service   Scoped objects are the same within a request  but different across different requests  Singleton objects are the same for every object and every request  regardless of whether an instance is provided in ConfigureServices

User · Answer

Singleton is a single instance for the lifetime of the application domain  Scoped is a single instance for the duration of the scoped request  which means per HTTP request in ASP NET  Transient is a single instance per code request    Normally the code request should be made through a constructor parameter  as in  public MyConsumingClass IDependency dependency    I wanted to point out in  akazemis s answer that  services  in the context of DI does not imply RESTful services  services are implementations of dependencies that provide functionality

User · Answer

AddSingleton   AddSingleton   creates a single instance of the service when it is first requested and reuses that same instance in all the places where that service is needed  AddScoped   In a scoped service  with every HTTP request  we get a new instance  However  within the same HTTP request  if the service is required in multiple places  like in the view and in the controller  then the same instance is provided for the entire scope of that HTTP request  But every new HTTP request will get a new instance of the service  AddTransient   With a transient service  a new instance is provided every time a service instance is requested whether it is in the scope of the same HTTP request or across different HTTP requests

[c#] AddTransient, AddScoped and AddSingleton Services Differences

Which one to use

Injecting service with different lifetimes into another

Examples related to c#

Examples related to asp.net-core

Examples related to .net-core