Dependency Injection в .NET на почтальонах

Наверное, все сталкивались с таким паттерном проектирования, как Inversion of control(IoC, инверсия управления) и его формой — Dependency Injection (DI, внедрение зависимостей). .NET и, в частности, .Net Core предоставляют этот механизм «из коробки». Очень важным моментом является такое понятие, как Lifetime или, время существования зависимости.

В .NET существует три способа зарегистрировать зависимость:

• AddTransient (Временная зависимость)

• AddScoped (Зависимость с заданной областью действия)

• AddSingleton (Одноэкземплярная зависимость)

Надо бы разобраться в различиях, поскольку и буквы в вышеописанных способах разные, и вообще, смысл слов тоже от способа к способу отличается. Хорошо, открываем поисковую систему и начинаем искать, в чём собственно различия. Так, везде написано про Asp.Net. Как же понять, как этот механизм работает в общем, отдельно от Asp.Net и запросов?

Перед тем, как приступить к рассмотрению различий, давайте немного освежим свои знания о составе механизма внедрения зависимостей, необходимого нам:

• IServiceCollection, представляет собой коллекцию дескрипторов служб

• IServiceProvider, представлет собой контейнер служб .NET

• IServiceScopeFactory, фабрика для создания служб с заданной областью

Все объяснения про различия времени существования разрешенной зависимости сводятся к приведению примеров, построенных на запросах к веб-приложению. Ну, в принципе понятно — новый запрос => новый сервис(за исключением AddSingleton). Что ж, давайте попробуем понять более подробно, в чём же всё-таки различия.

Приведу простой пример на почтальонах. Давайте представим, что мы ждём получения письма. В обязанности почтальона будет входить следующая последовательность действий:

1. Забрать письмо из отделения.

2. Донести письмо до адресата.

3. Получить подпись адресата о вручении.

4. Вручить письмо адресату.

Эти действия определим в интерфейсе IPostmanService:

using System;  namespace DependencyInjectionConsole.Interfaces {     public interface IPostmanService     {         void PickUpLetter(string postmanType);         void DeliverLetter(string postmanType);         void GetSignature(string postmanType);         void HandOverLetter(string postmanType);     } }

Также определим расширяющие интерфейс IPostmanService интерфейсы ITransientPostmanService, IScopedPostmanService, ISingletonPostmanService, для регистрации зависимости разными способами одной и той же реализации PostmanService:

using DependencyInjectionConsole.Interfaces; using Microsoft.Extensions.Logging; using System;  namespace DependencyInjectionConsole.Services {     public class PostmanService :          ITransientPostmanService,         IScopedPostmanService,         ISingletonPostmanService     {         private readonly string _name;         private readonly string[] _possibleNames = new string[] { "Peter", "Jack", "Bob", "Alex" };         private readonly string[] _possibleLastNames = new string[] { "Brown", "Jackson", "Gibson", "Williams" };         private readonly ILogger<PostmanService> _logger;          public PostmanService(ILogger<PostmanService> logger)         {             _logger = logger;              var rnd = new Random();             _name = $"{_possibleNames[rnd.Next(0, _possibleNames.Length - 1)]} {_possibleLastNames[rnd.Next(0, _possibleLastNames.Length - 1)]}";              _logger.LogInformation($"Hi! My name is {_name}.");         }          public void DeliverLetter(string postmanType)         {             _logger.LogInformation($"Postman {_name} delivered the letter. [{postmanType}]");         }          public void GetSignature(string postmanType)         {             _logger.LogInformation($"Postman {_name} got a signature. [{postmanType}]");         }          public void HandOverLetter(string postmanType)         {             _logger.LogInformation($"Postman {_name} handed the letter. [{postmanType}]");         }          public void PickUpLetter(string postmanType)         {             _logger.LogInformation($"Postman {_name} took the letter. [{postmanType}]");         }     } }

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

using DependencyInjectionConsole.Interfaces; using System;  namespace DependencyInjectionConsole {     public class PostmanHandler     {         private readonly ITransientPostmanService _transientPostman;         private readonly IScopedPostmanService _scopedPostman;         private readonly ISingletonPostmanService _singletonPostman;          public PostmanHandler(ITransientPostmanService transientPostman, IScopedPostmanService scopedPostman, ISingletonPostmanService singletonPostman)         {             _transientPostman = transientPostman;             _scopedPostman = scopedPostman;             _singletonPostman = singletonPostman;         }          public void PickUpLetter()         {             _transientPostman.PickUpLetter(nameof(_transientPostman));             _scopedPostman.PickUpLetter(nameof(_scopedPostman));             _singletonPostman.PickUpLetter(nameof(_singletonPostman));         }          public void DeliverLetter()         {             _transientPostman.DeliverLetter(nameof(_transientPostman));             _scopedPostman.DeliverLetter(nameof(_scopedPostman));             _singletonPostman.DeliverLetter(nameof(_singletonPostman));         }          public void GetSignature()         {             _transientPostman.GetSignature(nameof(_transientPostman));             _scopedPostman.GetSignature(nameof(_scopedPostman));             _singletonPostman.GetSignature(nameof(_singletonPostman));         }          public void HandOverLetter()         {             _transientPostman.HandOverLetter(nameof(_transientPostman));             _scopedPostman.HandOverLetter(nameof(_scopedPostman));             _singletonPostman.HandOverLetter(nameof(_singletonPostman));         }     } }

И наконец, определим код в классе Program:

using DependencyInjectionConsole.Interfaces; using DependencyInjectionConsole.Services; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using System;  namespace DependencyInjectionConsole {     class Program     {         private static IServiceCollection ConfigureServices()         {             var services = new ServiceCollection();             services.AddTransient<ITransientPostmanService, PostmanService>();             services.AddScoped<IScopedPostmanService, PostmanService>();             services.AddSingleton<ISingletonPostmanService, PostmanService>();              services.AddTransient<PostmanHandler>();              services.AddLogging(loggerBuilder =>             {                 loggerBuilder.ClearProviders();                 loggerBuilder.AddConsole();             });              return services;         }          static void Main(string[] args)         {             PostmanHandler postman;              var services = ConfigureServices();             var serviceProvider = services.BuildServiceProvider();             var scopeFactory = serviceProvider.GetService<IServiceScopeFactory>();              postman = serviceProvider.GetService<PostmanHandler>();              postman.PickUpLetter();             postman = serviceProvider.GetService<PostmanHandler>();             postman.DeliverLetter();             postman = serviceProvider.GetService<PostmanHandler>();             postman.GetSignature();             postman = serviceProvider.GetService<PostmanHandler>();             postman.HandOverLetter();              Console.WriteLine("-----------------Scope changed!---------------------");              using (var scope = scopeFactory.CreateScope())             {                 postman = scope.ServiceProvider.GetService<PostmanHandler>();                  postman.PickUpLetter();                 postman = serviceProvider.GetService<PostmanHandler>();                 postman.DeliverLetter();                 postman = serviceProvider.GetService<PostmanHandler>();                 postman.GetSignature();                 postman = serviceProvider.GetService<PostmanHandler>();                 postman.HandOverLetter();             }              Console.ReadKey();         }     } }

После запуска приложения мы увидим следующий вывод в консоли:

Пока немного отступим в сторону абстрактного объяснения на почтальонах.

Сначала посмотрим, как всё это будет выглядеть, если отделение почты зарегистрировало нам временного почтальона, т.е. воспользовавшись методом AddTransient:

Если перед выполнением каждого действия мы будем получать нового директора, то вместе с ним почтальон тоже будет создаваться новый. И так, каждое действие будет выполнять разный почтальон. Но, если директора мы будем использовать одного – то почтальон будет один.

Перейдём к более интересному способу регистрации зависимости – с заданной областью действия, т.е. AddScoped:

Нам абсолютно неважно, какой будет директор при выполнении каждого действия – каждый раз новый, или старый. Любой директор всегда будет вызывать одного и того же почтальона. Так будет происходить до тех пор, пока мы находимся в одной области (scope). Как только мы сменим область – почтальон также изменится. Этим и объясняются все примеры, связанные с Asp.Net – при каждом запросе создаётся новая область, в рамках которой выполняется работа.

И последний из способов – одноэкземплярная зависимость, т.е. AddSingleton:

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

Из консольного вывода мы видим, что наш временный почтальон всегда разный. Наш почтальон с заданной областью меняется лишь единожды — после смены области через IServiceScopeFactory.CreateScope(). Наш одноэкземплярный почтальон остаётся всегда одним, даже когда мы меняем область.

Есть одна особенность контейнера зависимостей, о которой разработчик на платформе .NET должен помнить всегда при создании программного продукта.

Если мы внедряем временную зависимость в зависимость с заданной областью, то она превращается в зависимость с заданной областью.
Например если мы зарегистрируем зависимость PostmanHandler как Scoped:

            var services = new ServiceCollection();             services.AddTransient<ITransientPostmanService, PostmanService>();             services.AddScoped<IScopedPostmanService, PostmanService>();             services.AddSingleton<ISingletonPostmanService, PostmanService>(); //Теперь зависимость нашего директора имеет тип Scoped             services.AddScoped<PostmanHandler>();              services.AddLogging(loggerBuilder =>             {                 loggerBuilder.ClearProviders();                 loggerBuilder.AddConsole();             });

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

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

            var services = new ServiceCollection();             services.AddTransient<ITransientPostmanService, PostmanService>();             services.AddScoped<IScopedPostmanService, PostmanService>();             services.AddSingleton<ISingletonPostmanService, PostmanService>(); //Теперь зависимость нашего директора имеет тип Singleton             services.AddSingleton<PostmanHandler>();              services.AddLogging(loggerBuilder =>             {                 loggerBuilder.ClearProviders();                 loggerBuilder.AddConsole();             });              return services;

Наши временный и с заданной областью почтальоны станут бесповоротно постоянными (одноэкземплярными) и мы увидим от них Hi! только единожды — при старте приложения.