Quelle est la différence entre les services.AddTransient, service.AddScoped et service.Méthodes AddSingleton dans ASP.NET noyau?

Pour plus de précisions, cet exemple de asp.net docs montre la différence :

Pour démontrer la différence entre ces options de durée de vie et d'enregistrement, considérons une interface simple qui représente une ou plusieurs tâches comme une opération avec un identifiant unique, OperationId. Selon la façon dont nous configurons La durée de vie de ce service, le conteneur fournira les mêmes instances ou des instances différentes du service à la classe requérante. Pour le rendre clair ce qui la durée de vie est demandée, nous allons créer un type par option de durée de vie:

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
    {
    }
}

Nous implémentons ces interfaces en utilisant une seule classe, Operation, qui accepte un Guid dans son constructeur, ou utilise un nouveau Guid si aucun n'est fourni.

Ensuite, dans ConfigureServices, chaque type est ajouté au conteneur en fonction de sa durée de vie nommée:

services.AddTransient<IOperationTransient, Operation>();
services.AddScoped<IOperationScoped, Operation>();
services.AddSingleton<IOperationSingleton, Operation>();
services.AddSingleton<IOperationSingletonInstance>(new Operation(Guid.Empty));
services.AddTransient<OperationService, OperationService>();

Notez que le service IOperationSingletonInstance utilise une instance spécifique avec un ID connu de Guid.Empty donc il sera clair quand ce type est utilisé. Nous avons également enregistré un {[11] } qui dépend de chacun des autres types Operation, de sorte qu'il sera clair dans une requête si ce service obtient la même instance que le contrôleur, ou une nouvelle, pour chaque type d'opération. Tout ce service expose ses dépendances en tant que propriétés, de sorte qu'elles peuvent être affichées dans la vue.

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;
        }
    }
}

Pour démontrer les durées de vie des objets dans et entre des requêtes individuelles distinctes à l'application, l'exemple comprend un OperationsController qui demande chaque type de type IOperation ainsi qu'un OperationService. L'action Index affiche ensuite toutes les valeurs OperationId du contrôleur et du service.

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();
        }
    }
}

Maintenant, deux requêtes distinctes sont faites à cette action du contrôleur:

Observez laquelle des valeurs OperationId varie au sein d'une requête et entre les requêtes.

• Les objets transitoires sont toujours différents; une nouvelle instance est fournie à chaque contrôleur et chaque service.

• Les objets de portée sont les mêmes dans une requête, mais différents selon les différentes requêtes

• Les objets Singleton sont les mêmes pour chaque objet et chaque requête (qu'une instance soit fournie ou non ConfigureServices)