Hola usuario de nuestra página web, descubrimos la solución a tu búsqueda, desplázate y la obtendrás un poco más abajo.
Solución:
TL; DR
Los objetos transitorios son siempre diferentes; Se proporciona una nueva instancia a cada controlador y a cada servicio.
Los objetos con ámbito son los mismos dentro de una solicitud, pero diferentes en diferentes solicitudes.
Los objetos singleton son los mismos para todos los objetos y solicitudes.
Para obtener más aclaraciones, este ejemplo de la documentación de .NET muestra la diferencia:
Para demostrar la diferencia entre estas opciones de registro y de vida útil, considere una interfaz simple que represente una o más tareas como una operación con un identificador único, OperationId. Dependiendo de cómo configuremos la vida útil de este servicio, el contenedor proporcionará instancias iguales o diferentes del servicio a la clase solicitante. Para dejar en claro qué ciclo de vida se solicita, crearemos un tipo de opción de ciclo de vida:
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
Implementamos estas interfaces usando una sola clase, Operation, que acepta un GUID en su constructor, o usa un nuevo GUID si no se proporciona ninguno:
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 => _guid;
A continuación, en ConfigureServices, cada tipo se agrega al contenedor de acuerdo con su vida útil nombrada:
services.AddTransient();
services.AddScoped();
services.AddSingleton();
services.AddSingleton(new Operation(Guid.Empty));
services.AddTransient();
Tenga en cuenta que el IOperationSingletonInstance el servicio está usando una instancia específica con un ID conocido de Guid.Empty, por lo que estará claro cuando este tipo esté en uso. También hemos registrado un OperationService eso depende el uno del otro Operation tipos, para que quede claro dentro de una solicitud si este servicio está obteniendo la misma instancia que el controlador, o una nueva, para cada tipo de operación. Todo lo que hace este servicio es exponer sus dependencias como propiedades, para que puedan mostrarse en la vista.
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;
Para demostrar la vida útil de los objetos dentro y entre solicitudes individuales separadas a la aplicación, la muestra incluye un OperationsController que solicita cada tipo de IOperation tipo así como un OperationService. los Index La acción luego muestra todos los controladores y servicios. OperationId valores.
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();
Ahora se realizan dos solicitudes separadas a esta acción del controlador:
Observe cuál de los OperationId los valores varían dentro de una solicitud y entre solicitudes.
-
Los objetos transitorios son siempre diferentes; Se proporciona una nueva instancia a cada controlador y a cada servicio.
-
Los objetos con ámbito son los mismos dentro de una solicitud, pero diferentes en diferentes solicitudes
-
Los objetos singleton son los mismos para todos los objetos y todas las solicitudes (independientemente de si se proporciona una instancia en
ConfigureServices)
En la inyección de dependencia de .NET hay tres vidas principales:
único que crea una única instancia en toda la aplicación. Crea la instancia por primera vez y reutiliza el mismo objeto en todas las llamadas.
Alcance Los servicios de por vida se crean una vez por solicitud dentro del alcance. Es equivalente a un singleton en el alcance actual. Por ejemplo, en MVC crea una instancia para cada solicitud HTTP, pero usa la misma instancia en las otras llamadas dentro de la misma solicitud web.
Transitorio Los servicios de por vida se crean cada vez que se solicitan. Esta vida útil funciona mejor para servicios ligeros y sin estado.
Aquí puede encontrar y ejemplos para ver la diferencia:
Inyección de dependencias ASP.NET 5 MVC6 en 6 pasos (enlace de archivo web debido a enlace muerto)
Su inyección de dependencia lista ASP.NET: ASP.NET 5
Y este es el enlace a la documentación oficial:
Inyección de dependencias en ASP.NET Core
Cual usar
Transitorio
- ya que se crean cada vez que usarán mas memoria & Recursos y puede tener un impacto negativo en el rendimiento.
- usa esto para el ligero servicio con poco o sin estado.
Alcance
- mejor opción cuando desea mantener el estado dentro de una solicitud.
único
- Las pérdidas de memoria en estos servicios se acumularán con el tiempo.
- también son eficientes en memoria, ya que se crean una vez que se reutilizan en todas partes.
Utilice Singletons donde necesite mantener el estado general de la aplicación. La configuración o los parámetros de la aplicación, el servicio de registro, el almacenamiento en caché de datos son algunos de los ejemplos en los que puede usar singletons.
Inyectando servicios con diferentes vidas útiles en otro
- Nunca inyecte servicios Scoped & Transient en el servicio Singleton. (Esto convierte efectivamente el servicio transitorio o de alcance en singleton).
- Nunca inyecte servicios transitorios en el servicio de ámbito (Esto convierte el servicio transitorio en el ámbito).