Я хочу реализовать внедрение зависимостей (DI) в ASP.NET Core. Поэтому после добавления этого кода в ConfigureServicesметод оба способа работают.

В чем разница между services.AddTransientи service.AddScopedметодов в ASP.NET Ядра?

public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.

    // Add application services.
    services.AddTransient<IEmailSender, AuthMessageSender>();
    services.AddScoped<IEmailSender, AuthMessageSender>();
}

TL; DR

Временные объекты всегда разные; новый экземпляр предоставляется каждому контроллеру и каждой службе.

Объекты области видимости одинаковы в запросе, но различны для разных запросов.

Объекты Singleton одинаковы для каждого объекта и каждого запроса.

Для большей ясности этот пример из документации ASP.NET показывает разницу:

Чтобы продемонстрировать разницу между этими параметрами времени жизни и регистрации, рассмотрим простой интерфейс, который представляет одну или несколько задач как операцию с уникальным идентификатором OperationId. В зависимости от того, как мы настроим время жизни для этой службы, контейнер предоставит запрашивающему классу либо одинаковые, либо разные экземпляры службы. Чтобы было ясно, какое время жизни запрашивается, мы создадим один тип на время жизни:

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

Мы реализуем эти интерфейсы, используя один класс, Operationкоторый принимает GUID в своем конструкторе, или использует новый GUID, если ни один не указан:

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

Далее, ConfigureServicesкаждый тип добавляется в контейнер в соответствии с его именованным временем жизни:

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

Обратите внимание, что IOperationSingletonInstanceслужба использует конкретный экземпляр с известным идентификатором Guid.Empty, поэтому будет понятно, когда этот тип используется. Мы также зарегистрировали значение OperationService, зависящее от каждого из других Operationтипов, чтобы в запросе было ясно, получает ли эта служба тот же экземпляр, что и контроллер, или новый экземпляр для каждого типа операции. Все, что делает этот сервис, представляет его зависимости как свойства, чтобы они могли отображаться в представлении.

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

Чтобы продемонстрировать время жизни объекта внутри и между отдельными индивидуальными запросами к приложению, образец включает в себя тип, OperationsControllerкоторый запрашивает каждый IOperationтип, а также тип OperationService. Затем Indexдействие отображает все значения контроллера и службы OperationId.

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

Теперь к этому действию контроллера подаются два отдельных запроса:

Обратите внимание, какое из OperationIdзначений варьируется в запросе и между запросами.

• Временные объекты всегда разные; новый экземпляр предоставляется каждому контроллеру и каждой службе.

• Объекты области видимости одинаковы в запросе, но различаются в разных запросах

• Объекты Singleton одинаковы для каждого объекта и каждого запроса (независимо от того, предоставлен ли экземпляр ConfigureServices)

В внедрении зависимостей .NET есть три основных срока службы:

Singleton, который создает один экземпляр во всем приложении. Он создает экземпляр в первый раз и повторно использует один и тот же объект во всех вызовах.

Сервисы с ограниченным сроком службы создаются один раз для каждого запроса в рамках области. Это эквивалентно синглтону в текущей области видимости. Например, в MVC он создает один экземпляр для каждого HTTP-запроса, но использует тот же экземпляр в других вызовах в рамках того же веб-запроса.

Временные службы продолжительности жизни создаются каждый раз, когда их запрашивают. Этот срок службы лучше всего подходит для легких служб без сохранения состояния.

Здесь вы можете найти и примеры, чтобы увидеть разницу:

ASP.NET 5 MVC6 Внедрение зависимостей за 6 шагов (ссылка на веб-архив из-за неработающей ссылки)

Ваша инъекция зависимостей готова ASP.NET: ASP.NET 5

А это ссылка на официальную документацию:

Внедрение зависимостей в ASP.NET Core

Transient, scoped и singleton определяют процесс создания объекта в базовом DI ASP.NET MVC, когда необходимо внедрить несколько объектов одного типа. Если вы новичок в внедрении зависимостей, вы можете посмотреть это видео DI IoC .

Вы можете увидеть код контроллера ниже, в котором я запросил два экземпляра «IDal» в конструкторе. Transient, Scoped и Singleton определяют, будет ли один и тот же экземпляр вставлен в «_dal» и «_dal1» или в другое.

public class CustomerController : Controller
{
    IDal dal = null;

    public CustomerController(IDal _dal,
                              IDal _dal1)
    {
        dal = _dal;
        // DI of MVC core
        // inversion of control
    }
}

Переходный процесс: В переходном режиме новые экземпляры объекта будут внедрены в один запрос и ответ. Ниже приведен снимок, на котором я отображал значения GUID.

Scoped: в Scoped один и тот же экземпляр объекта будет внедрен в один запрос и ответ.

Синглтон: в синглтоне один и тот же объект будет внедрен во все запросы и ответы. В этом случае будет создан один глобальный экземпляр объекта.

Ниже приведена простая диаграмма, которая визуально объясняет вышеизложенное.

Изображение выше было нарисовано командой SBSS, когда я проходил тренинг по ASP.NET MVC в Мумбаи . Большое спасибо команде SBSS за создание вышеуказанного изображения.

• Singleton - это единичный экземпляр на весь срок действия домена приложения.
• Scoped - это один экземпляр на время запроса с ограничением, что означает HTTP- запрос в ASP.NET.
• Переходный процесс - это отдельный экземпляр для каждого запроса кода .

Обычно запрос кода должен быть сделан через параметр конструктора, как в

public MyConsumingClass(IDependency dependency)

Я хотел бы указать в ответе @ akazemis, что «сервисы» в контексте DI не подразумевают сервисы RESTful; сервисы являются реализациями зависимостей, которые обеспечивают функциональность.

AddSingleton ()

AddSingleton () создает один экземпляр службы при первом запросе и повторно использует этот же экземпляр во всех местах, где требуется эта служба.

AddScoped ()

В сервисе с определенной областью, с каждым HTTP-запросом, мы получаем новый экземпляр. Однако в рамках одного и того же HTTP-запроса, если служба требуется в нескольких местах, например, в представлении и в контроллере, один и тот же экземпляр предоставляется для всей области действия этого HTTP-запроса. Но каждый новый HTTP-запрос будет получать новый экземпляр службы.

AddTransient ()

В случае временной службы новый экземпляр предоставляется каждый раз, когда запрашивается экземпляр службы, находится ли он в пределах одного и того же HTTP-запроса или в разных HTTP-запросах.

После поиска ответа на этот вопрос я нашел блестящее объяснение с примером, которым я хотел бы поделиться с вами.

Вы можете посмотреть видео, которое демонстрирует различия ЗДЕСЬ

В этом примере у нас есть этот код:

public interface IEmployeeRepository
{
    IEnumerable<Employee> GetAllEmployees();
    Employee Add(Employee employee);
}

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class MockEmployeeRepository : IEmployeeRepository
{
    private List<Employee> _employeeList;

    public MockEmployeeRepository()
    {
        _employeeList = new List<Employee>()
    {
        new Employee() { Id = 1, Name = "Mary" },
        new Employee() { Id = 2, Name = "John" },
        new Employee() { Id = 3, Name = "Sam" },
    };
    }

    public Employee Add(Employee employee)
    {
        employee.Id = _employeeList.Max(e => e.Id) + 1;
        _employeeList.Add(employee);
        return employee;
    }

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

Создать вид

@model Employee
@inject IEmployeeRepository empRepository

<form asp-controller="home" asp-action="create" method="post">
    <div>
        <label asp-for="Name"></label>
        <div>
            <input asp-for="Name">
        </div>
    </div>

    <div>
        <button type="submit">Create</button>
    </div>

    <div>
        Total Employees Count = @empRepository.GetAllEmployees().Count().ToString()
    </div>
</form>

Startup.cs

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
    services.AddSingleton<IEmployeeRepository, MockEmployeeRepository>();
}

Скопируйте и вставьте этот код и нажмите кнопку «Создать» в представлении и переключайтесь между ними AddSingleton, AddScopedи AddTransientкаждый раз вы будете получать другой результат, который может помочь вам понять это объяснение:

AddSingleton () - Как видно из названия, метод AddSingleton () создает службу Singleton. Сервис Singleton создается при первом запросе. Этот же экземпляр затем используется всеми последующими запросами. Таким образом, в общем случае служба Singleton создается только один раз для каждого приложения, и этот единственный экземпляр используется в течение всего срока службы приложения.

AddTransient () - этот метод создает временный сервис. Новый экземпляр временной службы создается каждый раз, когда она запрашивается.

AddScoped () - этот метод создает сервис Scoped. Новый экземпляр службы Scoped создается один раз для каждого запроса в области. Например, в веб-приложении оно создает 1 экземпляр для каждого http-запроса, но использует тот же экземпляр в других вызовах в рамках того же веб-запроса.

Какой использовать

преходящий

• так как они создаются каждый раз, когда они будут использовать больше памяти и ресурсов и могут оказать негативное влияние на производительность
• используйте это для облегченного обслуживания с небольшим или никаким государством .

Scoped

• лучший вариант, когда вы хотите сохранить состояние в запросе.

одиночка

• утечки памяти в этих сервисах будут накапливаться со временем.
• Кроме того, эффективна память, поскольку они создаются после повторного использования везде.

Используйте Singletons там, где вам нужно поддерживать состояние приложения. Конфигурация приложения или параметры, служба регистрации, кэширование данных - вот некоторые примеры, где вы можете использовать синглтоны.

Внедрение службы с разными временами жизни в другой

1. Никогда не вводите сервисы Scoped & Transient в сервис Singleton. (Это эффективно преобразует временный или ограниченный сервис в синглтон.)
2. Никогда не вводите временные службы в ограниченную службу (это преобразует временную службу в определенную область).

Как описано здесь (эта ссылка очень полезна) с примером,

Это отображение между интерфейсом и конкретным типом определяет, что каждый раз, когда вы запрашиваете тип IContryService, вы получаете новый экземпляр CountryService. Вот что означает переходный процесс в этом случае. Вы также можете добавлять одноэлементные сопоставления (используя AddSingleton) и сопоставления областей (используя AddScoped). В данном случае под областью действия подразумевается область действия для HTTP-запроса, что также означает, что он является одноэлементным во время выполнения текущего запроса. Вы также можете добавить существующий экземпляр в контейнер DI, используя метод AddInstance. Это почти полные способы регистрации на IServiceCollection.

Регистрационные Услуги

Ядро ASP.NET предоставляет следующие 3 метода для регистрации служб в контейнере внедрения зависимостей. Метод, который мы используем, определяет время жизни зарегистрированного сервиса.

AddSingleton () - Как видно из названия, метод AddSingleton () создает службу Singleton. Сервис Singleton создается при первом запросе. Этот же экземпляр затем используется всеми последующими запросами. Таким образом, в общем случае служба Singleton создается только один раз для каждого приложения, и этот единственный экземпляр используется в течение всего срока службы приложения.

AddTransient () - этот метод создает временный сервис. Новый экземпляр временной службы создается каждый раз, когда она запрашивается.

AddScoped () - этот метод создает сервис Scoped. Новый экземпляр службы Scoped создается один раз для каждого запроса в области. Например, в веб-приложении оно создает 1 экземпляр для каждого http-запроса, но использует тот же экземпляр в других вызовах в рамках того же веб-запроса.