Делегаты и события C# в лучших практиках Event-Driven программирования

public delegate int CalculationOperation(int firstValue, int secondValue);

public static int Add(int x, int y) => x + y;
 
CalculationOperation calc = Add;
int result = calc(5, 10); // result = 15

   Action<string> logMessage = msg => Console.WriteLine($"LOG: {msg}");
   logMessage("Приложение запущено");

   Func<double, double> square = x => x * x;
   Console.WriteLine(square(4.5)); // 20.25

   Predicate<int> isPositive = n => n > 0;
   Console.WriteLine(isPositive(-5)); // false

Func<Func<int, int>, Func<int, int>> compose = f => g => x => f(g(x));
 
Func<int, int> addFive = x => x + 5;
Func<int, int> multiplyByThree = x => x * 3;
 
var addAndMultiply = compose(multiplyByThree)(addFive);
Console.WriteLine(addAndMultiply(10)); // (10 + 5) * 3 = 45

public delegate void Notification(string message);
 
static void EmailAlert(string msg) => Console.WriteLine($"EMAIL: {msg}");
static void SmsAlert(string msg) => Console.WriteLine($"SMS: {msg}");
static void PushAlert(string msg) => Console.WriteLine($"PUSH: {msg}");
 
// Создаём и комбинируем делегат
Notification notify = EmailAlert;
notify += SmsAlert;
notify += PushAlert;
 
// Один вызов - три метода
notify("Сервер перезагружен");

Func<int, int> transformations = x => {
    Console.WriteLine($"Добавляем 1: {x} -> {x+1}");
    return x + 1;
};
 
transformations += x => {
    Console.WriteLine($"Умножаем на 2: {x} -> {x*2}");
    return x * 2;
};
 
int result = transformations(5);
// Выведет:
// Добавляем 1: 5 -> 6
// Умножаем на 2: 5 -> 10
// result = 10 (только результат последнего метода)

notify -= SmsAlert; // удаляем один из обработчиков

// Старый способ (C# 1.0)
button.Click += new EventHandler(Button_Click);
void Button_Click(object sender, EventArgs e) { 
    Console.WriteLine("Кнопка нажата"); 
}
 
// Анонимный метод (C# 2.0)
button.Click += delegate(object sender, EventArgs e) { 
    Console.WriteLine("Кнопка нажата"); 
};
 
// Лямбда-выражение (C# 3.0+)
button.Click += (sender, e) => Console.WriteLine("Кнопка нажата");

// Лямбда-выражение (expression lambda)
Func<int, int, int> add = (x, y) => x + y;
 
// Лямбда-оператор (statement lambda)
Func<int, int, int> complexCalculation = (x, y) => {
    int result = 0;
    for (int i = 0; i < y; i++) {
        result += x;
    }
    return result;
};

int counter = 0;
Func<int> getNextNumber = () => ++counter;
 
Console.WriteLine(getNextNumber()); // 1
Console.WriteLine(getNextNumber()); // 2
Console.WriteLine(counter);         // 2

class Animal { }
class Dog : Animal { }

// Ковариантность - возвращаемый тип может быть более конкретным
Func<Animal> getAnimal = () => new Dog(); // Возвращаем Dog вместо Animal
 
// Контравариантность - параметр может быть более общим
Action<Dog> processDog = dog => { /* что-то делаем */ };
Action<Animal> processAnimal = processDog; // Требует Animal, но принимает Dog

// Обобщённый делегат для трансформации данных
public delegate TResult Transformer<T, TResult>(T input);
 
// Использование
Transformer<string, int> getLength = s => s.Length;
Console.WriteLine(getLength("Hello, world!")); // 13

Dictionary<string, Func<int, int, int>> operations = new() {
    { "add", (a, b) => a + b },
    { "subtract", (a, b) => a - b },
    { "multiply", (a, b) => a * b },
    { "divide", (a, b) => b != 0 ? a / b : throw new DivideByZeroException() }
};
 
// Использование
string operation = "multiply";
int result = operations[operation](10, 5); // 50

public class Publisher {
    // Событие - объявляется с ключевым словом event
    public event EventHandler SomethingHappened;
 
    public void DoSomething() {
        // Вызов события (только внутри класса)
        SomethingHappened?.Invoke(this, EventArgs.Empty);
    }
}
 
public class Subscriber {
    public void RegisterWithPublisher(Publisher publisher) {
        // Подписка на событие (извне доступны только += и -=)
        publisher.SomethingHappened += OnSomethingHappened;
    }
 
    private void OnSomethingHappened(object sender, EventArgs e) {
        Console.WriteLine("Получено событие!");
    }
}

public delegate void EventHandler(object sender, EventArgs e);
public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);

public class PriceChangedEventArgs : EventArgs {
    public decimal OldPrice { get; }
    public decimal NewPrice { get; }
 
    public PriceChangedEventArgs(decimal oldPrice, decimal newPrice) {
        OldPrice = oldPrice;
        NewPrice = newPrice;
    }
}
 
public class Product {
    private decimal _price;
    
    public event EventHandler<PriceChangedEventArgs> PriceChanged;
    
    public decimal Price {
        get => _price;
        set {
            if (_price == value) return;
            
            decimal oldPrice = _price;
            _price = value;
            
            // Вызываем событие с данными об изменении
            PriceChanged?.Invoke(this, new PriceChangedEventArgs(oldPrice, _price));
        }
    }
}

public event EventHandler<MouseEventArgs> MouseMove;

private EventHandler<MouseEventArgs> _mouseMove;
 
public event EventHandler<MouseEventArgs> MouseMove {
    add { _mouseMove += value; Console.WriteLine("Добавлен обработчик"); }
    remove { _mouseMove -= value; Console.WriteLine("Удалён обработчик"); }
}

public static event EventHandler<AppDomainInitializedEventArgs> DomainInitialized;

public class Button {
    public event EventHandler Clicked;
    
    protected virtual void OnClicked() {
        // Проверка на null с использованием оператора ?. (C# 6.0+)
        Clicked?.Invoke(this, EventArgs.Empty);
        
        // Альтернативный подход (до C# 6.0)
        // var handler = Clicked;
        // if (handler != null) handler(this, EventArgs.Empty);
    }
    
    public void SimulateClick() {
        // Какая-то логика...
        OnClicked();
    }
}

// Проблемный код (не используйте его в реальных проектах!)
public void InvokeEvent()
{
    // Поток 1 вызывает событие
    MyEvent(this, EventArgs.Empty);  // Может вызвать NullReferenceException
}
 
public void UnsubscribeFromEvent()
{
    // Поток 2 отписывается от события
    MyEvent -= MyEventHandler;
}

public void InvokeEventSafely()
{
    // Создаём локальную копию делегата
    var handler = MyEvent;
    
    // Проверяем на null и вызываем безопасно
    if (handler != null)
    {
        handler(this, EventArgs.Empty);
    }
}

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

// В WPF приложении
Application.Current.Dispatcher.Invoke(() => {
    MyEvent?.Invoke(this, EventArgs.Empty);
});
 
// В WinForms
if (control.InvokeRequired)
{
    control.Invoke(new Action(() => MyEvent?.Invoke(this, EventArgs.Empty)));
}
else
{
    MyEvent?.Invoke(this, EventArgs.Empty);
}

public class EventPublisher
{
    public event EventHandler SomeEvent;
    
    public void RaiseEvent()
    {
        SomeEvent?.Invoke(this, EventArgs.Empty);
    }
}
 
public class ShortLivedSubscriber
{
    private readonly EventPublisher _publisher;
    
    public ShortLivedSubscriber(EventPublisher publisher)
    {
        _publisher = publisher;
        _publisher.SomeEvent += OnSomeEvent;  // Подписка на событие
    }
    
    private void OnSomeEvent(object sender, EventArgs e)
    {
        Console.WriteLine("Событие получено!");
    }
    
    // Забыли отписаться от события при уничтожении объекта!
}

public void Dispose()
{
    _publisher.SomeEvent -= OnSomeEvent;
}

public class WeakEventManager<TEventArgs> where TEventArgs : EventArgs
{
    private readonly Dictionary<WeakReference, Action<object, TEventArgs>> _handlers = 
        new Dictionary<WeakReference, Action<object, TEventArgs>>();
    
    public void AddHandler(object subscriber, Action<object, TEventArgs> handler)
    {
        _handlers.Add(new WeakReference(subscriber), handler);
    }
    
    public void RemoveHandler(object subscriber)
    {
        var keyToRemove = _handlers.Keys.FirstOrDefault(wr => wr.Target == subscriber);
        if (keyToRemove != null)
        {
            _handlers.Remove(keyToRemove);
        }
    }
    
    public void RaiseEvent(object sender, TEventArgs args)
    {
        foreach (var pair in _handlers.ToList())
        {
            if (pair.Key.Target is object target)
            {
                pair.Value(sender, args);
            }
            else
            {
                // Объект больше не существует, удаляем его обработчик
                _handlers.Remove(pair.Key);
            }
        }
    }
}

// Использование Rx.NET
IDisposable subscription = Observable.FromEventPattern<EventArgs>(
    h => source.SomeEvent += h,
    h => source.SomeEvent -= h)
    .Subscribe(pattern => Console.WriteLine("Событие получено!"));
 
// Отписка просто вызывает Dispose
subscription.Dispose();

public class TextProcessor
{
    private Func<string, string> _processingStrategy;
 
    public void SetStrategy(Func<string, string> strategy)
    {
        _processingStrategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
    }
 
    public string ProcessText(string input)
    {
        return _processingStrategy != null 
            ? _processingStrategy(input) 
            : throw new InvalidOperationException("Стратегия обработки не установлена");
    }
}
 
// Применение
var processor = new TextProcessor();
 
// Устанавливаем разные стратегии с помощью лямбд
processor.SetStrategy(s => s.ToUpper()); // Стратегия превращения в верхний регистр
Console.WriteLine(processor.ProcessText("привет, мир")); // ПРИВЕТ, МИР
 
processor.SetStrategy(s => new string(s.Reverse().ToArray())); // Стратегия переворота
Console.WriteLine(processor.ProcessText("привет, мир")); // рим ,тевирп
 
processor.SetStrategy(s => string.Join(" ", s.Split(' ').Select(word => word.Length.ToString()))); // Длина слов
Console.WriteLine(processor.ProcessText("привет, мир")); // 7 3

// Базовый класс для всех игровых событий
public class GameEvent : EventArgs
{
    public DateTime Timestamp { get; } = DateTime.Now;
}
 
// События, связанные с персонажами
public class CharacterEvent : GameEvent
{
    public Character Character { get; }
 
    public CharacterEvent(Character character)
    {
        Character = character;
    }
}
 
// Конкретное событие - персонаж получил урон
public class CharacterDamagedEvent : CharacterEvent
{
    public int DamageAmount { get; }
    public DamageType DamageType { get; }
 
    public CharacterDamagedEvent(Character character, int damage, DamageType type) : base(character)
    {
        DamageAmount = damage;
        DamageType = type;
    }
}
 
// Менеджер событий - центральная точка управления событиями
public class EventManager
{
    private static EventManager _instance;
    public static EventManager Instance => _instance ??= new EventManager();
 
    // Словарь для хранения всех событий и их подписчиков
    private Dictionary<Type, Delegate> _events = new Dictionary<Type, Delegate>();
 
    // Подписка на определенный тип события
    public void Subscribe<T>(Action<T> handler) where T : GameEvent
    {
        var eventType = typeof(T);
        
        if (_events.TryGetValue(eventType, out var existingHandlers))
        {
            _events[eventType] = Delegate.Combine(existingHandlers, handler);
        }
        else
        {
            _events[eventType] = handler;
        }
    }
 
    // Отписка от события
    public void Unsubscribe<T>(Action<T> handler) where T : GameEvent
    {
        var eventType = typeof(T);
        
        if (_events.TryGetValue(eventType, out var existingHandlers))
        {
            _events[eventType] = Delegate.Remove(existingHandlers, handler);
            
            if (_events[eventType] == null)
            {
                _events.Remove(eventType);
            }
        }
    }
 
    // Публикация события
    public void Publish<T>(T gameEvent) where T : GameEvent
    {
        var eventType = typeof(T);
        
        if (_events.TryGetValue(eventType, out var handlers) && handlers != null)
        {
            // Вызываем всех обработчиков этого типа события
            ((Action<T>)handlers)(gameEvent);
        }
        
        // Также можем вызвать обработчики для базовых типов события
        if (eventType != typeof(GameEvent))
        {
            var baseType = eventType.BaseType;
            while (baseType != null && baseType != typeof(object))
            {
                if (_events.TryGetValue(baseType, out var baseHandlers) && baseHandlers != null)
                {
                    // Создаём метод для приведения типов и вызова базовых обработчиков
                    var method = baseHandlers.GetType().GetMethod("Invoke");
                    method.Invoke(baseHandlers, new object[] { gameEvent });
                }
                
                baseType = baseType.BaseType;
            }
        }
    }
}

// Класс, который реагирует на урон персонажа
public class DamageVisualizer
{
    public DamageVisualizer()
    {
        // Подписываемся на события урона
        EventManager.Instance.Subscribe<CharacterDamagedEvent>(OnCharacterDamaged);
    }
 
    private void OnCharacterDamaged(CharacterDamagedEvent e)
    {
        // Отображаем полученный урон над персонажем
        Console.WriteLine($"{e.Character.Name} получил {e.DamageAmount} урона типа {e.DamageType}");
        
        // Воспроизводим соответствующую анимацию
        if (e.DamageType == DamageType.Fire)
        {
            PlayFireDamageAnimation(e.Character);
        }
    }
 
    private void PlayFireDamageAnimation(Character character)
    {
        // Здесь был бы код воспроизведеня анимации огня
    }
 
    public void Dispose()
    {
        // При уничтожении объекта не забываем отписаться!
        EventManager.Instance.Unsubscribe<CharacterDamagedEvent>(OnCharacterDamaged);
    }
}

public class FileDownloader
{
    public event EventHandler<FileDownloadEventArgs> DownloadCompleted;
    
    public async Task DownloadFileAsync(string url)
    {
        // Имитация скачивания файла
        await Task.Delay(2000);
        var data = new byte[1024]; // Представим, что это скачанные данные
        
        // Вызываем событие из асинхронного метода
        OnDownloadCompleted(new FileDownloadEventArgs(url, data));
    }
    
    protected virtual void OnDownloadCompleted(FileDownloadEventArgs e)
    {
        DownloadCompleted?.Invoke(this, e);
    }
}
 
// Подписка с использованием асинхронного обработчика
fileDownloader.DownloadCompleted += async (sender, e) =>
{
    // Асинхронно обрабатываем скачанный файл
    await ProcessDownloadedFileAsync(e.Data);
    
    // И обновляем UI
    await UpdateUIAsync();
};

fileDownloader.DownloadCompleted += async (sender, e) =>
{
    try
    {
        await ProcessDownloadedFileAsync(e.Data);
        await UpdateUIAsync();
    }
    catch (Exception ex)
    {
        // Обрабатываем ошибку
        LogError(ex);
        MessageBox.Show($"Не удалось обработать загруженный файл: {ex.Message}");
    }
};

// Создаём наблюдаемую последовательность из события
var mouseMove = Observable.FromEventPattern<MouseEventArgs>(
    h => form.MouseMove += h,
    h => form.MouseMove -= h);
 
// Трансформируем события в координаты
var mouseCoordinates = mouseMove
    .Select(pattern => pattern.EventArgs.Location);
 
// Фильтруем, берем только каждое 10-е событие для оптимизации
var throttledMouse = mouseCoordinates
    .Where((point, index) => index % 10 == 0);
 
// Подписываемся на отфильтрованную последовательность
var subscription = throttledMouse.Subscribe(point =>
    Console.WriteLine($"Мышь переместилась в {point.X}, {point.Y}"));
 
// Позже отписываемся
subscription.Dispose();

var clicks = Observable.FromEventPattern<EventArgs>(
    h => button.Click += h,
    h => button.Click -= h);
 
// Определяем двойной клик как два клика в течение 300 мс
var doubleClicks = clicks
    .Buffer(TimeSpan.FromMilliseconds(300))
    .Where(events => events.Count >= 2);
 
doubleClicks.Subscribe(_ => Console.WriteLine("Двойной клик обнаружен!"));

public class TemperatureSensor : IObservable<double>
{
    private readonly List<IObserver<double>> _observers = new List<IObserver<double>>();
    private readonly Random _random = new Random();
    private CancellationTokenSource _cts;
    private double _baseTemperature = 20.0; // Базовая температура в Цельсиях
    
    public IDisposable Subscribe(IObserver<double> observer)
    {
        if (!_observers.Contains(observer))
            _observers.Add(observer);
            
        if (_cts == null)
            StartReading();
            
        return new Unsubscriber<double>(_observers, observer);
    }
    
    private async void StartReading()
    {
        _cts = new CancellationTokenSource();
        
        try
        {
            while (!_cts.Token.IsCancellationRequested)
            {
                // Имитируем измерение температуры с небольшими колебаниями
                double currentTemp = _baseTemperature + (_random.NextDouble() * 2 - 1);
                
                foreach (var observer in _observers.ToArray())
                {
                    observer.OnNext(currentTemp);
                }
                
                // Ждем некоторое время перед следующим измерением
                await Task.Delay(1000, _cts.Token);
                
                // Медленно меняем базовую температуру
                _baseTemperature += _random.NextDouble() * 0.1 - 0.05;
            }
        }
        catch (OperationCanceledException)
        {
            // Нормальное завершение при отмене
        }
        catch (Exception ex)
        {
            // Уведомляем подписчиков об ошибке
            foreach (var observer in _observers.ToArray())
            {
                observer.OnError(ex);
            }
        }
        finally
        {
            _cts = null;
        }
    }
    
    public void StopReading()
    {
        _cts?.Cancel();
    }
    
    // Вспомогательный класс для отписки
    private class Unsubscriber<T> : IDisposable
    {
        private readonly List<IObserver<T>> _observers;
        private readonly IObserver<T> _observer;
        
        public Unsubscriber(List<IObserver<T>> observers, IObserver<T> observer)
        {
            _observers = observers;
            _observer = observer;
        }
        
        public void Dispose()
        {
            if (_observer != null && _observers.Contains(_observer))
                _observers.Remove(_observer);
        }
    }
}

var sensor = new TemperatureSensor();
 
// Создаём наблюдателя
var temperatureDisplay = Observer.Create<double>(
    temp => Console.WriteLine($"Текущая температура: {temp:F1}°C"),
    ex => Console.WriteLine($"Ошибка датчика: {ex.Message}"),
    () => Console.WriteLine("Измерения завершены")
);
 
// Подписываемся на датчик
var subscription = sensor.Subscribe(temperatureDisplay);
 
// ...Позже отписываемся
subscription.Dispose();

// Отфильтровываем только значения выше 21 градуса
var highTemperatures = sensor.Where(temp => temp > 21);
 
// Группируем по целым значениям и вычисляем среднее
var averagesByInteger = sensor
    .GroupBy(temp => (int)temp)
    .Select(group => new { Temperature = group.Key, Average = group.Average() });
 
// Следим за скоростью изменения
var temperatureChanges = sensor
    .Buffer(2, 1) // Буферизуем по 2 значения с шагом 1
    .Select(buffer => buffer.Count < 2 ? 0 : buffer[1] - buffer[0]);

// Неоптимально: создание делегата в цикле
for (int i = 0; i < 10000; i++)
{
    Func<int, int> calculator = x => x * x;
    results[i] = calculator(i);
}
 
// Оптимально: создание делегата один раз
Func<int, int> calculatorOptimized = x => x * x;
for (int i = 0; i < 10000; i++)
{
    results[i] = calculatorOptimized(i);
}

// Медленнее, если вызывается часто и имеет много подписчиков
public event EventHandler DataUpdated;
 
// На более прямые вызовы через интерфейс
public interface IDataUpdateListener
{
    void OnDataUpdated(object sender, EventArgs e);
}
 
private readonly List<IDataUpdateListener> _listeners = new List<IDataUpdateListener>();

public class ResourceHog
{
    private readonly byte[] _largeArray = new byte[1024 * 1024 * 100]; // 100 MB
    
    public void RegisterCallback(EventPublisher publisher)
    {
        // Эта лямбда захватывает 'this', удерживая весь объект в памяти!
        publisher.SomeEvent += (sender, e) => Console.WriteLine($"Size: {_largeArray.Length}");
    }
}

// Лучше: избегаем захвата всего объекта
var arraySize = _largeArray.Length; // Захватываем только то, что нужно
publisher.SomeEvent += (sender, e) => Console.WriteLine($"Size: {arraySize}");

// Без кэширования — для каждого вызова создаётся новый делегат
dataItems.Where(item => item.IsValid)
         .Select(item => item.Value)
         .ToList();
 
// С кэшированием — один делегат для многократного использования
private static readonly Func<DataItem, bool> IsValidFunc = item => item.IsValid;
private static readonly Func<DataItem, double> GetValueFunc = item => item.Value;
 
// Использование
dataItems.Where(IsValidFunc)
         .Select(GetValueFunc)
         .ToList();

public class BankAccount
{
    private decimal _balance;
    private readonly List<AccountEvent> _events = new List<AccountEvent>();
    
    public void Deposit(decimal amount)
    {
        var @event = new DepositEvent { Amount = amount, Timestamp = DateTime.Now };
        ApplyEvent(@event);
        _events.Add(@event);
    }
    
    public void Withdraw(decimal amount)
    {
        if (_balance < amount)
            throw new InvalidOperationException("Insufficient funds");
            
        var @event = new WithdrawalEvent { Amount = amount, Timestamp = DateTime.Now };
        ApplyEvent(@event);
        _events.Add(@event);
    }
    
    private void ApplyEvent(AccountEvent @event)
    {
        switch (@event)
        {
            case DepositEvent depositEvent:
                _balance += depositEvent.Amount;
                break;
            case WithdrawalEvent withdrawalEvent:
                _balance -= withdrawalEvent.Amount;
                break;
        }
    }
    
    public void ReplayEvents()
    {
        _balance = 0;
        foreach (var @event in _events)
        {
            ApplyEvent(@event);
        }
    }
}
 
// События
public abstract class AccountEvent
{
    public DateTime Timestamp { get; set; }
}
 
public class DepositEvent : AccountEvent
{
    public decimal Amount { get; set; }
}
 
public class WithdrawalEvent : AccountEvent
{
    public decimal Amount { get; set; }
}

public class EventAggregator
{
    private readonly Dictionary<Type, List<object>> _subscribers = new Dictionary<Type, List<object>>();
    
    public void Subscribe<T>(Action<T> subscriber)
    {
        var type = typeof(T);
        if (!_subscribers.ContainsKey(type))
            _subscribers[type] = new List<object>();
            
        _subscribers[type].Add(subscriber);
    }
    
    public void Publish<T>(T message)
    {
        var type = typeof(T);
        if (!_subscribers.ContainsKey(type))
            return;
            
        foreach (var subscriber in _subscribers[type].OfType<Action<T>>().ToList())
        {
            subscriber(message);
        }
    }
    
    public void Unsubscribe<T>(Action<T> subscriber)
    {
        var type = typeof(T);
        if (!_subscribers.ContainsKey(type))
            return;
            
        _subscribers[type].Remove(subscriber);
    }
}

// Потенциально опасный код в многопоточной среде
public event EventHandler StateChanged;
 
public void UpdateState()
{
    // Изменение состояния и оповещение
    _state = CalculateNewState();
    StateChanged?.Invoke(this, EventArgs.Empty);
}

// Вариант 1: Блокировка на время вызова события
private readonly object _eventLock = new object();
 
public void UpdateState()
{
    // Изменение состояния безопасным образом
    _state = CalculateNewState();
    
    // Блокируем на время вызова события
    lock (_eventLock)
    {
        StateChanged?.Invoke(this, EventArgs.Empty);
    }
}

// Вариант 2: Очередь событий
private readonly ConcurrentQueue<EventData> _eventQueue = new ConcurrentQueue<EventData>();
private readonly AutoResetEvent _processingSignal = new AutoResetEvent(false);
private readonly Thread _processingThread;
 
private class EventData
{
    public object Sender { get; set; }
    public EventArgs Args { get; set; }
    public EventHandler Handler { get; set; }
}
 
public MyClass()
{
    // Создаём и запускаем поток обработки событий
    _processingThread = new Thread(ProcessEvents)
    {
        IsBackground = true,
        Name = "EventProcessingThread"
    };
    _processingThread.Start();
}
 
public void UpdateState()
{
    _state = CalculateNewState();
    
    // Вместо прямого вызова, добавляем в очередь
    var handler = StateChanged;
    if (handler != null)
    {
        _eventQueue.Enqueue(new EventData
        {
            Sender = this,
            Args = EventArgs.Empty,
            Handler = handler
        });
        _processingSignal.Set(); // Сигнализируем о новом событии
    }
}
 
private void ProcessEvents()
{
    while (true)
    {
        // Ждём сигнала о новых событиях
        _processingSignal.WaitOne();
        
        // Обрабатываем все события в очереди
        while (_eventQueue.TryDequeue(out var eventData))
        {
            try
            {
                eventData.Handler(eventData.Sender, eventData.Args);
            }
            catch (Exception ex)
            {
                // Логируем ошибку, но продолжаем обработку
                Console.WriteLine($"Error in event handler: {ex.Message}");
            }
        }
    }
}

// Временная обёртка для отладки вызовов события
public event EventHandler<OrderEventArgs> OrderProcessed
{
    add
    {
        Console.WriteLine($"[DEBUG] Подписка на OrderProcessed: {value.Method.Name}");
        _orderProcessed += value;
    }
    remove
    {
        Console.WriteLine($"[DEBUG] Отписка от OrderProcessed: {value.Method.Name}");
        _orderProcessed -= value;
    }
}
 
private EventHandler<OrderEventArgs> _orderProcessed;
 
protected virtual void OnOrderProcessed(OrderEventArgs e)
{
    Console.WriteLine($"[DEBUG] Вызов OrderProcessed, заказ №{e.OrderId}");
    _orderProcessed?.Invoke(this, e);
}

private Stopwatch _sw = new Stopwatch();
private long _totalEventTime = 0;
private int _eventCallCount = 0;
 
protected virtual void OnDataReceived(DataReceivedEventArgs e)
{
    _sw.Restart();
    DataReceived?.Invoke(this, e);
    _sw.Stop();
    
    // Собираем статистику
    Interlocked.Add(ref _totalEventTime, _sw.ElapsedMilliseconds);
    Interlocked.Increment(ref _eventCallCount);
    
    // Периодически выводим отчёт
    if (_eventCallCount % 1000 == 0)
    {
        Console.WriteLine($"Event stats: {_eventCallCount} calls, avg {_totalEventTime / _eventCallCount} ms per call");
    }
}