AddTransient VS AddScoped VS AddSingleton In .NET Core

In this article, we will learn about AddTransient, AddScoped, and AddSingleton in .NET Core.

DI (Dependency Injection) is a technique for achieving loose coupling between objects and their dependencies. To implement Dependency Injection, we need to configure a DI container with classes that are participating in DI. DI Container has to decide whether to provide an existing instance or return a new instance of the service. In Startup.cs class file, we perform this activity on the ConfigureServices() method.

The lifetime of service depends on when a dependency is instantiated and how long it lives. And lifetime depends on how we have registered these services.

There are three methods that define the lifetime of the services in Startup.cs.
1. AddTransient 2. AddScoped  3. AddSingleton

Parameter Add Transient Add Scoped Add Singleton
Meaning Transient lifetime services are created each time when they are requested. Scoped lifetime services are created once per request. Singleton lifetime services are created only the first time when they are requested (or when ConfigureServices is run if you specify an instance there).
Description It means the Transient lifetime service creates a new instance for every controller/service as well as for every request and every user. It means the Scoped objects are the same within a request, but different across different requests. It means the Singleton lifetime service creates the instance for the first request then the same is available throughout the application and for each subsequent request.
Used In This lifetime works best for lightweight and stateless services. This lifetime works best for applications which have different behavior per user. This lifetime used, when Singleton implementation is required.
Syntax services.AddTransient() services.AddScoped() services.AddSingleton()
Disposed End of request End of request App shutdown

Service Type In the scope of given HTTP request Across different HTTP requests
Transient New Instance New Instance
Scoped Same Instance New Instance
Singleton Same Instance Same Instance

Example

Prerequisites:

  • Basic knowledge of .NET Core
  • Code editor like Visual Studio

Create a folder named Interfaces and add a new file IOperation.cs in it.

using System;

namespace DependencyInjectionDemo.Interfaces
{
    public interface IOperation
    {
        Guid OperationId { get; }
    }

    public interface IOperationTransient : IOperation
    {
    }

    public interface IOperationScoped : IOperation
    {
    }

    public interface IOperationSingleton : IOperation
    {
    }
}

Create a folder named Classes and add a new file Operation.cs in it.

using DependencyInjectionDemo.Interfaces;
using System;

namespace DependencyInjectionDemo.Classes
{
    public class Operation : IOperationTransient, IOperationScoped, IOperationSingleton
    {
        Guid guid;
        public Operation() : this(Guid.NewGuid())
        {

        }

        public Operation(Guid _guid)
        {
            guid = _guid;
        }

        public Guid OperationId => guid;
    }
}

Now, open the Startup.cs file and add the following code to in ConfigureServices() method.

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllersWithViews();
    services.AddTransient<IOperationTransient, Operation>();
    services.AddScoped<IOperationScoped, Operation>();
    services.AddSingleton<IOperationSingleton, Operation>();
}

Now, open the HomeController and add the following code to it.

using DependencyInjectionDemo.Interfaces;
using Microsoft.AspNetCore.Mvc;

namespace DependencyInjectionDemo.Controllers
{
    public class HomeController : Controller
    {
        private readonly IOperationTransient _transientOperation1;
        private readonly IOperationScoped _scopedOperation1;
        private readonly IOperationSingleton _singletonOperation1;
        private readonly IOperationTransient _transientOperation2;
        private readonly IOperationScoped _scopedOperation2;
        private readonly IOperationSingleton _singletonOperation2;

        public HomeController(IOperationTransient transientOperation1, IOperationScoped scopedOperation1, IOperationSingleton singletonOperation1, IOperationTransient transientOperation2, IOperationScoped scopedOperation2, IOperationSingleton singletonOperation2)
        {
            _transientOperation1 = transientOperation1;
            _scopedOperation1 = scopedOperation1;
            _singletonOperation1 = singletonOperation1;
            _transientOperation2 = transientOperation2;
            _scopedOperation2 = scopedOperation2;
            _singletonOperation2 = singletonOperation2;
        }

        public IActionResult Index()
        {
            //Controller Operation
            ViewBag.Transient1 = _transientOperation1.OperationId.ToString();
            ViewBag.Scoped1 = _scopedOperation1.OperationId.ToString();
            ViewBag.Singleton1 = _singletonOperation1.OperationId.ToString();

            //Operation Service Operation
            ViewBag.Transient2 = _transientOperation2.OperationId.ToString();
            ViewBag.Scoped2 = _scopedOperation2.OperationId.ToString();
            ViewBag.Singleton2 = _singletonOperation2.OperationId.ToString();
            return View();
        }
    }
}

Output:

Please give your valuable feedback and if you have any questions or issues about this article, please let me know.

Also, check Allow CORS Requests From Any Origin In .NET Core

Submit a Comment

Your email address will not be published. Required fields are marked *

Subscribe

Select Categories