Dependency Injection

Certainly! In .NET Core, AddScoped, AddTransient, and AddSingleton are methods used to register services with the built-in dependency injection container. Here's a breakdown of the differences between them along with examples:

1. AddScoped:

   • Usage: services.AddScoped();
   • Explanation: Services registered with AddScoped are created once per request. That means a single instance of the service is created for the duration of an HTTP request. If the service is requested multiple times within the same request, the same instance will be reused.

   
   services.AddScoped();
   

2. AddTransient:

   • Usage: services.AddTransient();
   • Explanation: Services registered with AddTransient are created each time they are requested. This results in a new instance of the service being created for every request, ensuring freshness but potentially leading to a higher resource consumption.

   
   services.AddTransient();
   

3. AddSingleton:

   • Usage: services.AddSingleton();
   • Explanation: Services registered with AddSingleton are created only once and the same instance is used for the entire lifetime of the application. This means that the instance is shared across all requests and clients.

   
   services.AddSingleton();
   

Example Scenario:

Let's consider a simple scenario where you have a service that counts the number of times it has been instantiated:

public interface ICounter
{
    int GetCount();
}

public class Counter : ICounter
{
    private int _count = 0;

    public Counter()
    {
        _count++;
    }

    public int GetCount()
    {
        return _count;
    }
}

Now, let's register this service using different lifetimes:

// Using AddScoped
services.AddScoped();

// Using AddTransient
services.AddTransient();

// Using AddSingleton
services.AddSingleton();

In this example:

• With AddScoped, the counter will increment once per HTTP request.
• With AddTransient, the counter will increment every time the service is requested.
• With AddSingleton, the counter will increment only once for the entire lifetime of the application, regardless of how many times the service is requested.

Hi Umesh,

// Singleton

builder.Services.AddSingleton();

???????// Scoped

builder.Services.AddScoped();


// Transient

builder.Services.AddTransient();

 

Singleton creates a single instance once and reuses the same object in all calls. Use Singletons where you need to maintain pplication-wide state, for example, application configuration, logging service, caching of data, etc.

• Singletons are memory efficient as they are created once and reused everywhere.
• Memory leaks in these services will build up over time.

Scoped lifetime services are created once per request. 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.

• Scoped is a good option when you want to maintain state within a request.

Transient lifetime services are created each time they are requested. This lifetime works best for lightweight, stateless services. Since they are created every time, they will use more memory & resources and can have a negative impact on performance.

• Transient is good for lightweight services with little or no state.

Also, refer to below Articles
https://www.c-sharpcorner.com/article/addtransient-vs-addscoped-vs-addsingleton/#:~:text=Stateful%20services%20that%20need%20to,can%20be%20registered%20as%20AddSingleton.

https://www.linkedin.com/pulse/differences-between-addtransient-addscoped-addsingleton-mia-7vg6c

In ASP.NET Core, AddScoped, AddTransient, and AddSingleton are methods used to register services with different lifetimes in the dependency injection container. Here’s a brief explanation of each:

1. AddTransient: This method creates a new instance of the service each time it is requested, regardless of whether it’s within the same HTTP request or a different one12.

2. AddScoped: This method creates a new instance of the service for each HTTP request. This means that within the same HTTP request, you’ll get the same instance of the service12.

3. AddSingleton: This method creates a single instance of the service when it is first requested (or when ConfigureServices is run if you specify an instance there). Every subsequent request will use the same instance2.

Here’s an example of how you might register services using these methods:

public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient();
    services.AddScoped();
    services.AddSingleton();
}

In this example, OperationService is a class that implements three interfaces: ITransientService, IScopedService, and ISingletonService. Each interface is registered with a different lifetime. When these services are requested (for example, via constructor injection in a controller), the dependency injection container will provide instances according to the lifetime specified in ConfigureServices2.

Reffer below link: 

https://www.c-sharpcorner.com/article/understanding-addtransient-vs-addscoped-vs-addsingleton-in-asp-net-core/

Thanks