SavePearlHarbor

События в .NET: стандартная реализация, альтернативы, и причем тут сахар

—

от автора

admin

События – это объекты, которые получают уведомления о некотором действии в разрабатываемом ПО и могут запускать реакции на это действие. Разработчик может определить эти действия, добавив к событию обработчик. Разберем в этом материале само понятие событий в .NET и разные способы работы с ними.

Объясним на сахаре

Если говорить простым языком, то можно провести аналогию с просыпанным сахаром. Например, у нас в руках была сахарница, и мы сахар из нее рассыпали – это событие. Что делать, если рассыпался сахар? Идти за веником, чтобы убрать – это и есть обработчик события. Этот обработчик с предназначенным для него действием «сидит у нас в голове». Даже если сахар мы никогда не просыпали, мы все равно знаем, что веником его можно будет убрать. 

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

О событиях в C#

В C# события существуют с самого начала. Например, при создании элементарного приложения Web Forms, для обработки нажатия на кнопку нужно добавить конструкцию вида

MyButton.Click += new EventHandler(this.MyBtn_Click);

Сlick – это и есть событие, которое уже было добавлено разработчиками в класс Button, а MyBtn_Click – это обработчик, написанный программистом. 

Сейчас события используются реже, но возможность создавать и использовать их сохранилась. Так как же это устроено изнутри?

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

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

В C# события – это отдельный тип членов класса, обозначаемый ключевым словом event. Наряду со свойствами и параметрами.

Класс, который реализует событие, должен содержать следующую конструкцию:

event тип_делегата имя_события;

  • тип_делегата указывает на прототип вызываемого метода (или методов);

  • имя_события – конкретный объект объявляемого события.

Добавление обработчика события производится с помощью операции += :

имя_события += обработчик_события;

Разберем добавление обработки событий на примере логирования. Здесь, и в дальнейшем, мы будем использовать консольное приложение .Net 7.0, C# 11. 

class Program {     static void Main()     {         EmailService emailService = new EmailService(emailFrom: "hr@disney.com");          // Добавляем обработчик события         emailService.MailSent += LogToConsole;          emailService.SendMail(emailTo: "Milo.Murphy@disney.com", subject: "Welcome to Disney", body: "Today is your first day...");     }      // Обработчик, который логирует в консоль отправленное сообщение     static void LogToConsole(MailSentEventArgs eventArgs)         => Console.WriteLine(             $"[Консоль] Письмо с темой '{eventArgs.Subject}' отправлено с адреса '{eventArgs.EmailFrom}' на адрес '{eventArgs.EmailTo}': {eventArgs.Body}"); }  // Класс в котором реализовано событие class EmailService {     private readonly string _emailFrom;      public EmailService(string emailFrom)     {         _emailFrom = emailFrom;     }      // Объявляем событие     public event MailSentEventHandler? MailSent;      public void SendMail(string emailTo, string subject, string body)     {         // Отправляем письмо пользователю...         // Send(_emailFrom, emailTo, subject, body);          // Вызываем метод запуска события         var eventArgs = new MailSentEventArgs         {             EmailFrom = _emailFrom,             EmailTo = emailTo,             Subject = subject,             Body = body         };         OnMailSent(eventArgs);     }      // Используем метод для запуска события     protected virtual void OnMailSent(MailSentEventArgs eventArgs)     {         MailSentEventHandler? mailSentHandler = MailSent;         if (mailSentHandler != null)         {             mailSentHandler(eventArgs);         }     } }  // Объявляем тип события public delegate void MailSentEventHandler(MailSentEventArgs eventArgs);  public record MailSentEventArgs {     public string? EmailFrom { get; init; }     public string? EmailTo { get; init; }     public string? Subject { get; init; }     public string? Body { get; init; } }

Мы добавили событие MailSent в класс EmailService и добавили обработчик этого события LogToConsole.

Результат:

[Консоль] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day...

Добавление и удаление обработчиков

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

Цепочка обработчиков реализуется через Delegate.Combine. То есть физически каждый делегат содержит ссылку на реализацию, внутри которой ссылка на следующую реализацию. Обработчик можно удалить в процессе.

static void Main()     {         EmailService emailService = new EmailService(emailFrom: "hr@disney.com");          // Добавляем обработчик события         emailService.MailSent += LogToConsole;         emailService.MailSent += LogToFile;          emailService.SendMail(emailTo: "Milo.Murphy@disney.com", subject: "Welcome to Disney", body: "Today is your first day...");          emailService.MailSent -= LogToFile;         emailService.SendMail(emailTo: "Milo.Murphy@disney.com", subject: "Welcome to Disney", body: "Today is your first day...");     }      // Обработчик, который логирует в консоль отправленное сообщение     static void LogToConsole(MailSentEventArgs eventArgs)         => Console.WriteLine(             $"[Консоль] Письмо с темой '{eventArgs.Subject}' отправлено с адреса '{eventArgs.EmailFrom}' на адрес '{eventArgs.EmailTo}': {eventArgs.Body}");      // Обработчик, который логирует в файл отправленное сообщение     static void LogToFile(MailSentEventArgs eventArgs)         => Console.WriteLine(             $"[Файл] Письмо с темой '{eventArgs.Subject}' отправлено с адреса '{eventArgs.EmailFrom}' на адрес '{eventArgs.EmailTo}': {eventArgs.Body}");

Результат:

[Консоль] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day... [Файл] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day... [Консоль] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day...

Если нужно выполнить какие-то действия при добавлении или удалении обработчика, можно переписать функции add/remove у делегата. Мы добавим логирование к действиям добавления/удаления обработчика.

private MailSentEventHandler? mailSent; public event MailSentEventHandler MailSent { add { mailSent += value; Console.WriteLine($"Обработчик {value.Method.Name} добавлен"); } remove { Console.WriteLine($"Обработчик {value.Method.Name} удален"); mailSent -= value; } }

Результат:

Обработчик LogToConsole добавлен Обработчик LogToFile добавлен [Консоль] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day... [Файл] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day... Обработчик LogToFile удален [Консоль] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day..

Если в обработчике произойдет ошибка – ошибка будет на уровне приложения. Если добавить try catch при вызове обработчика, то в случае, если произойдет ошибка в первом обработчике, последующие обработчики выполняться не будут. Поэтому следует предусмотреть это в каждом обработчике.

static void LogToConsole(MailSentEventArgs eventArgs) { try { throw new Exception("Ошибка записи"); } catch (Exception e) { Console.WriteLine(e); } }

EventHandler

В .NET существует делегат EventHandler, предназначенный как раз для объявления события и принимающий определенный тип входных параметров.

Классы, которые мы собираемся использовать для хранения информации, передаваемой обработчику события, должны наследоваться от типа System.EventArgs. При этом имя типа желательно заканчивать словом EventArgs.

Начиная с .NET Framework 4.5 наследованиe аргументов от System.EventArgs стало не обязательным, но в примере мы его оставим, это никак не повлияет на результат.

Создадим тип параметров, используемых обработчиками:

public class MailSentEventArgs : EventArgs { public string? EmailFrom { get; init; } public string? EmailTo { get; init; } public string? Subject { get; init; } public string? Body { get; init; } }

И тогда событие может быть объявлено как

public event EventHandler<MailSentEventArgs>? MailSent;

При этом обработчик должен принимать параметры object sender и MailSentEventArgs args. Где sender – текущий элемент класса, в котором определен event, a args – передаваемые обработчику данные. Обработчик может быть использован для событий в разных классах, поэтому разумнее принимать экземпляр типа object, а не конкретного типа. Так как в этом случае в метод обработчика могут приходить данные от разных событий, но с одинаковыми параметрами.

То есть обработчики будут выглядеть так:

public static void LogToConsole(object? sender, MailSentEventArgs args)         => Console.WriteLine(             $"[Консоль] Письмо с темой '{args.Subject}' отправлено с адреса '{args.EmailFrom}' на адрес '{args.EmailTo}': {args.Body}");        public static void LogToFile(object? sender, MailSentEventArgs args)         => Console.WriteLine(             $"[Файл] Письмо с темой '{args.Subject}' отправлено с адреса '{args.EmailFrom}' на адрес '{args.EmailTo}': {args.Body}")

А вызов, поскольку событие представляет собой делегат, например, так:

MailSent?.Invoke(this, eventArgs);

Порой необходимо передать внутрь функции какие-то данные, а порой действие будет выполняться независимо от внешних данных – тогда передавать внутрь функции ничего не нужно. В случаях, когда не нужно передавать в обработчик никаких данных, мы можем воспользоваться EventArgs.Empty.  То есть объявление события не будет указывать тип аргумента:

public event EventHandler? MailSent;

Обработчик при этом должен принимать object sender и EventArgs:

static void LogToConsole(object? sender, EventArgs eventArgs) => Console.WriteLine("[Консоль] Отправлено письмо");

а вызов будет выглядеть так:

MailSent?.Invoke(this, EventArgs.Empty);

AsyncEventHandler

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

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

Тогда объявлять событие мы будем так:

public event AsyncEventHandler<MailSentEventArgs>? MailSent;

Обработчик будет выглядеть так:

static Task LogToConsoleAsync(object? sender, MailSentEventArgs args) { Console.WriteLine( $"[Консоль] Письмо с темой '{args.Subject}' отправлено с адреса '{args.EmailFrom}' на адрес '{args.EmailTo}': {args.Body}"); return Task.CompletedTask; }

а вызываться так:

await MailSent?.InvokeAsync(this, new MailSentEventArgs());

Реализация событий компилятором

Несколько слов о представлении событий в IL-кодe. При компиляции кроме объявления события также создаются два метода add и remove: они реализуют конструкции += и –=.  

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

public event MailSentEventHandler MailSent {     [NullableContext(2)]     [CompilerGenerated]     add     {         MailSentEventHandler mailSentEventHandler = this.MailSent;         while (true)         {             // берем текущий делегат             MailSentEventHandler mailSentEventHandler2 = mailSentEventHandler;              // добавляем к текущему делегату новый             MailSentEventHandler value2 = (MailSentEventHandler)Delegate                                          .Combine(mailSentEventHandler2, value);              // сравниваем MailSent и mailSentEventHandler2             // и, если они равны, заменяем MailSent на value2             // а в mailSentEventHandler записываем исходное значение MailSent             mailSentEventHandler = Interlocked              .CompareExchange(ref this.MailSent, value2, mailSentEventHandler2);              // если предыдущая операция выполнилась успешно - заканчиваем             // это нужно для безопасной многопоточной работы - если в             // параллельном потоке у события изменится список делегатов,             // то while запустится повторно и добавит новый делегат к уже            // обновленной цепочке делегатов             if ((object)mailSentEventHandler == mailSentEventHandler2)             {                 break;             }         }     }     [NullableContext(2)]     [CompilerGenerated]     remove     {         MailSentEventHandler mailSentEventHandler = this.MailSent;         while (true)         {             // берем текущий делегат             MailSentEventHandler mailSentEventHandler2 = mailSentEventHandler;              // удаляем из него value             MailSentEventHandler value2 = (MailSentEventHandler)Delegate                                           .Remove(mailSentEventHandler2, value);              // сравниваем MailSent и mailSentEventHandler2             // и, если они равны, заменяем MailSent на value2             // а в mailSentEventHandler записываем исходное значение MailSent                         mailSentEventHandler = Interlocked              .CompareExchange(ref this.MailSent, value2, mailSentEventHandler2);              // если предыдущая операция выполнилась успешно - заканчиваем             if ((object)mailSentEventHandler == mailSentEventHandler2)             {                 break;             }         }     } }

Паттерн «Наблюдатель»

Реализация событий укладывается в паттерн «Наблюдатель», суть которого в наличии одного наблюдаемого объекта и нескольких наблюдателей. Если возвращаться к аналогии с сахаром, в рамках паттерна сахарница будет наблюдаемым объектом, а человек, который рассыпал сахар или просто находился рядом – наблюдателем. Наблюдателей может быть больше одного (кто-то с веником, а кто-то с пылесосом). Далее, когда рассыпается сахар, сначала один наблюдатель делает свои действия, а другой следом – свои.

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

Ниже приведен пример реализации этого паттерна без использования событий.

class Program {     static void Main()     {         EmailService emailService = new EmailService("hr@disney.com");          // Добавляем обработчик события         var consoleObserver = new ConsoleObserver(emailService);         var fileObserver = new FileObserver(emailService);          emailService.SendMail(             emailTo: "Milo.Murphy@disney.com",             subject: "Welcome to Disney",             body: "Today is your first day...");          fileObserver.StopObserve();          emailService.SendMail(             emailTo: "Milo.Murphy@disney.com",             subject: "Welcome to Disney",             body: "Today is your first day...");     } }  interface IObserver {     void Update(string emailFrom, string emailTo, string subject, string body); }  interface IObservable {     void RegisterObserver(IObserver o);     void RemoveObserver(IObserver o); }  class EmailService : IObservable {     private readonly List<IObserver> _observers;     private readonly string _emailFrom;      public EmailService(string emailFrom)     {         _emailFrom = emailFrom;         _observers = new List<IObserver>();     }      public void RegisterObserver(IObserver o)     {         _observers.Add(o);     }      public void RemoveObserver(IObserver o)     {         _observers.Remove(o);     }      protected void MailSent(string emailTo, string subject, string body)     {         foreach (IObserver o in _observers)         {             o.Update(_emailFrom, emailTo, subject, body);         }     }      public void SendMail(string emailTo, string subject, string body)     {         // Отправить письмо пользователю         //Send(_emailFrom, emailTo, subject, body);          // Запускаем методы наблюдателей         MailSent(emailTo, subject, body);     } }  class ConsoleObserver : IObserver {     IObservable? _stock;     public ConsoleObserver(IObservable obs)     {         _stock = obs;         _stock.RegisterObserver(this);     }     public void Update(         string emailFrom,         string emailTo,         string subject,         string body)     {         Console.WriteLine($"[Консоль] Письмо с темой '{subject}' отправлено с адреса '{emailFrom}' на адрес '{emailTo}': {body}");     }      public void StopObserve()     {         if (_stock is null)         {             return;         }         _stock.RemoveObserver(this);         _stock = null;     } }  class FileObserver : IObserver {     IObservable? _stock;     public FileObserver(IObservable obs)     {         _stock = obs;         _stock.RegisterObserver(this);     }      public void Update(         string emailFrom,         string emailTo,         string subject,         string body)     {         Console.WriteLine($"[Файл] Письмо с темой '{subject}' отправлено с адреса '{emailFrom}' на адрес '{emailTo}': {body}");     }      public void StopObserve()     {         if (_stock is null)         {             return;         }         _stock.RemoveObserver(this);         _stock = null;     } }

Результат:

[Консоль] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day... [Файл] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day... [Консоль] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day...

Минусы и плюсы такой реализации паттерна «Наблюдатель»

Минусы

  • в этой реализации нам пришлось самим писать интерфейсы, а для событий есть прописанные интерфейсы и классы, которыми остается только воспользоваться;

  • более высокий порог вхождения – нужно разобраться с работой паттерна;

  • под каждое событие придется писать свой набор интерфейсов из-за различий данных события, передаваемых в метод IObserver.Update (либо аналогично событиям использовать тип object, но тогда теряется наглядность);

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

Плюсы

  • подобную реализацию можно использовать также в языках, где нет делегатов – например, С++;

  • можно обеспечить распараллеливание реакции наблюдателей;

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

  • точные контракты: есть конкретные методы с конкретным набором параметров под нужное событие, а не набор параметров вида «object sender, EventArgs e».

MediatR

В библиотеке MediatR из коробки есть своя реализация событий. Это не существующие в C# события, но есть некоторое сходство.

Как следует из названия, MediatR – это реализация паттерна «Посредник». Суть паттерна в создании прослойки между частями кода. Это нужно в случае наличия большого количества связей между объектами – есть вероятность запутать логику реализации. 

«Посредник» ограничивает объекты от явных ссылок друг на друга, уменьшая количество взаимосвязей. Основной принцип реализации в том, что мы создаем объект и можем добавить обработчики для него. При этом достаточно использовать у типа отправляемого объекта интерфейс IRequest  или INotification и указать у обработчика интерфейс, связанный с типом объекта. Тогда MediatR вызовет нужный обработчик при выполнении команды Send для интерфейса IRequest и Publish для интерфейса INotification, в который будет передан объект.

Обычно при работе с библиотекой MediatR используются интерфейсы IRequest и IRequestHandler. Тип, используемый медиатором, должен быть унаследован от IRequest<TResponse>, где TResponse – результат обработки запроса, а обработчик должен поддерживать интерфейс IRequestHandler<TRequest, TResponse>, где TRequest – созданный нами тип с интерфейсом IRequest. Но нужно помнить, что обработчик здесь может быть только один.

Для случая множества обработчиков в MediatR был создан интерфейс INotification. И, соответственно, обработчики должны поддерживать интерфейс INotificationHandler<TRequest>.

Рассмотрим пример (необходимо установить nuget-пакет MediatR и nuget-пакет Microsoft.Extensions.DependencyInjection):

using System.Reflection; using MediatR; using Microsoft.Extensions.DependencyInjection;  class Program {     static async Task Main()     {         var serviceCollection = new ServiceCollection()             .AddMediatR(cfg =>          cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()))             .BuildServiceProvider();          var mediator = serviceCollection.GetRequiredService<IMediator>();         EmailService emailService = new EmailService(mediator, "hr@disney.com");          await emailService.SendMailToUserAsync(             emailTo: "Milo.Murphy@disney.com",             subject: "Welcome to Disney",             body: "Today is your first day...");     } }  class MailSentRequest : INotification {     public string? EmailFrom { get; init; }     public string? EmailTo { get; init; }     public string? Subject { get; init; }     public string? Body { get; init; } }  class ConsoleHandler : INotificationHandler<MailSentRequest> {     public Task Handle(         MailSentRequest request,         CancellationToken cancellationToken) { Console.WriteLine( $"[Консоль] Письмо с темой '{request.Subject}' отправлено с адреса '{request.EmailFrom}' на адрес '{request.EmailTo}': {request.Body}"); return Task.CompletedTask; } }  class FileHandler : INotificationHandler<MailSentRequest> {     public Task Handle(         MailSentRequest request,         CancellationToken cancellationToken) { Console.WriteLine( $"[Файл] Письмо с темой '{request.Subject}' отправлено с адреса '{request.EmailFrom}' на адрес '{request.EmailTo}': {request.Body}"); return Task.CompletedTask; } }  class EmailService {     private readonly string _emailFrom;     private readonly IMediator _mediator;      public EmailService(IMediator mediator, string emailFrom)     {         _mediator = mediator;         _emailFrom = emailFrom;     }      public async Task SendMailToUserAsync(         string emailTo,         string subject,         string body)     {         // Отправить письмо пользователю         //Send(_emailFrom, emailTo, subject, body);         // Вызываем метод запуска события         await MailSentAsync(_emailFrom, emailTo, subject, body);     }      protected async Task MailSentAsync(string emailFrom, string emailTo, string subject, string body)     {         var request = new MailSentRequest         {             EmailFrom = emailFrom,             EmailTo = emailTo,             Subject = subject,             Body = body         };         await _mediator.Publish(request);     } }

Результат:

[Консоль] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day... [Файл] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day...

Плюсы и минусы использования MediatR:

Плюс

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

Минусы

  • классы хэндлеров помечаются не используемыми (это можно исправить, навесив атрибут [UsedImplicitly]);

  • нельзя «по щелчку» перейти к реализации;

  • не всегда очевидно, какие хэндлеры будут вызваны при вызове медиатора;

  • не получится во время выполнения программы добавить/удалить обработчик;

  • невозможно (или сложно) установить четкий порядок вызова обработчика. Он больше подходит для вызова независимых друг от друга обработчиков.

Есть способ обойти второй минус из перечисленных. Нужно реализацию запроса и обработчик поместить в один partial-класс:

public partial class MailSent {   public class Request : INotification   { public string? EmailFrom { get; init; } public string? EmailTo { get; init; } public string? Subject { get; init; } public string? Body { get; init; }   } }  public partial class MailSent {   public class ConsoleHandler : INotificationHandler<Request>   {     public Task Handle( Request request, CancellationToken cancellationToken) { Console.WriteLine( $"[Консоль] Письмо с темой '{request.Subject}' отправлено с адреса '{request.EmailFrom}' на адрес '{request.EmailTo}': {request.Body}"); return Task.CompletedTask; }   } }  public partial class MailSent {   public class FileHandler : INotificationHandler<Request>   {     public Task Handle( Request request, CancellationToken cancellationToken) { Console.WriteLine( $"[Файл] Письмо с темой '{request.Subject}' отправлено с адреса '{request.EmailFrom}' на адрес '{request.EmailTo}': {request.Body}"); return Task.CompletedTask; }   } }

тогда при создании запроса нужно указывать оба класса:

protected async Task MailSentAsync( string emailFrom, string emailTo, string subject, string body) { var request = new MailSent.Request { EmailFrom = emailFrom, EmailTo = emailTo, Subject = subject, Body = body }; await _mediator.Publish(request); }

При попытке перейти «по щелчку» к классу MailSent нам будет предложен выбор перейти к запросу или к реализации.

 Дополнительные возможности

В MediatR есть удобная реализация поведения конвейера (pipeline behavior). Для этого используется интерфейс IPipelineBehavior<TRequest, TResponse>.

services.AddScoped(typeof(IPipelineBehavior<,>), typeof(MailSentBehavior<,>));     class MailSentBehavior<TRequest, TResponse>      : IPipelineBehavior<TRequest, TResponse>  {       public async Task<TResponse> Handle(             TRequest request,             RequestHandlerDelegate<TResponse> next,             CancellationToken cancellationToken)       {             try             {                   Console.WriteLine($"Перед запуском {typeof(TRequest).Name}");                   return await next();             }             finally             {                   Console.WriteLine($"После запуска {typeof(TRequest).Name}");             }     }   }

Так, можно добавить какую-то обработку для каждого вызова Handle из классов унаследованных от IRequestHandler. Например, логирование, на примере которого мы рассматривали реализацию обработки событий.

К сожалению, мы можем использовать PipelineBehavior только для  IRequest и не можем для INotification.

Чтобы реализовать подобную функциональность для событий нужно переопределить NotificationPublisher.

class Program {     static async Task Main()     {         var serviceCollection = new ServiceCollection()             .AddMediatR(config =>         {            config.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly());            config.NotificationPublisher = new MailSentPublisher();            config.NotificationPublisherType = typeof(MailSentPublisher);         })             .BuildServiceProvider();          var mediator = serviceCollection.GetRequiredService<IMediator>();         EmailService emailService =                 new EmailService(mediator: mediator, emailFrom: "hr@disney.com");          await emailService.SendMailToUserAsync( emailTo: "Milo.Murphy@disney.com", subject: "Welcome to Disney", body: "Today is your first day...");     } }  class MailSentPublisher : INotificationPublisher {     public async Task Publish( IEnumerable<NotificationHandlerExecutor> handlerExecutors, INotification notification, CancellationToken cancellationToken)     {         foreach (var handler in handlerExecutors)         {             try             {                 Console.WriteLine( $"Перед запуском {handler.HandlerInstance.GetType().Name}");                 await handler.HandlerCallback(notification, cancellationToken) .ConfigureAwait(false);             }             catch (Exception e)             {                 Console.WriteLine($"Произошла ошибка {e.Message}");             }             finally             {                 Console.WriteLine( $"После запуска {handler.HandlerInstance.GetType().Name}");             }         }     } }

Результат:

Перед запуском ConsoleHandler [Консоль] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day... После запуска ConsoleHandler Перед запуском FileHandler [Файл] Письмо с темой 'Welcome to Disney' отправлено с адреса 'hr@disney.com' на адрес 'Milo.Murphy@disney.com': Today is your first day... После запуска FileHandler

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

Вместо заключения

Мы рассмотрели несколько вариантов реализации обработчиков Событий: с помощью стандартных средств C#, с помощью средств библиотеки MediatR и написали самостоятельно, реализовав паттерн Наблюдатель. В разных ситуациях может быть удобно использовать разные варианты, но полезно знать и об альтернативных возможностях.


ссылка на оригинал статьи https://habr.com/ru/articles/809467/

Комментарии

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *