Qwen, CancelationToken, Try, Catch, ExecuteAsync, StartAsync, StopAsync, ActionBlockHubDemoSln.slnx

Qwen, CancelationToken, Try, Catch, ExecuteAsync, StartAsync, StopAsync, ActionBlockHubDemoSln.slnx

D:\Projects\VS02\2606\TplDataflow\Qwen\ActionBlockHubDemoSln\ActionBlockHubDemoSln.slnx

D:\Projects\VS02\2606\TplDataflow\Qwen\ActionBlockHubDemoSln\ActionBlockHubDemo03\ActionBlockHubDemo03.csproj

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    try
    {
        await Task.Delay(2000, stoppingToken);
        _logger.LogInformation("MetricsService запущен. Начинаем мониторинг...");

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                foreach (var key in _keys) // Используем ключи из конфига
                {
                    _logger.LogInformation(
                        "📊 Метрика [{Key}]: Успешно = {Processed}, Ошибок = {Errors}",
                        key, _actionHub.GetProcessedCount(key), _actionHub.GetErrorCount(key));
                }
                await Task.Delay(5000, stoppingToken);
            }
            catch (OperationCanceledException)
            {
                // Логируем, если была отменена сама операция.
                _logger.LogWarning("Operation was cancelled by CancellationToken.");
                break;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "MetricsService: Произошла ошибка {Message}", ex.Message);
            }
        }
    }
    finally
    {
        _logger.LogInformation("MetricsService is shutting down gracefully...");
    }
}

---------------
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    try
    {
        _logger.LogInformation("📈 Генератор котировок запущен.");

        while (!stoppingToken.IsCancellationRequested)
        {
            var quotesBatch = GenerateQuotesBatch();

            _logger.LogDebug($"--- Новая порция котировок ({quotesBatch.Count} шт.) ---");

            // Параллельная обработка текущей партии котировок
            await Parallel.ForEachAsync(
                quotesBatch,
                new ParallelOptions
                {
                    MaxDegreeOfParallelism = Environment.ProcessorCount,
                    CancellationToken = stoppingToken
                },
                async (quote, token) =>
                {
                    await _handler.HandleAsync(quote, token);
                });

            // Ждем перед генерацией следующей порции
            await Task.Delay(TimeSpan.FromSeconds(1), stoppingToken);
        }

        _logger.LogInformation("🛑 Генератор котировок остановлен.");
    }
    catch (OperationCanceledException)
    {
        // Эта секция выполнится, когда сервис остановят
        _logger.LogInformation("Фоновая задача была корректно прервана.");
    }
    finally
    {
        // Здесь можно освободить ресурсы, если они есть
        _logger.LogInformation("Сервис QuoteGeneratorService полностью остановлен.");
    }
}
----------------------------------------------------------------------------
// --- НОВАЯ РЕАЛИЗАЦИЯ СТАРТА ---
public override async Task StartAsync(CancellationToken cancellationToken)
{
    _logger.LogInformation("📈 Генератор котировок готовится к запуску...");

    // Здесь может быть логика инициализации, например:
    // await InitializeDatabaseConnectionAsync(cancellationToken);

    _logger.LogInformation("🚀 Инициализация завершена. Запуск основного цикла.");

    // Вызываем стандартный старт, который начнет ExecuteAsync
    await base.StartAsync(cancellationToken);
}
---------------------------------------------------------------------------------
public override async Task StopAsync(CancellationToken cancellationToken)
{
    _logger.LogWarning("⚠️ Получен сигнал об остановке сервиса.");

    // Здесь может быть логика очистки, например:
    // await SaveFinalStateToDatabaseAsync(cancellationToken);
    // CloseFileHandles();

    // _logger.LogInformation("🛑 Сервис успешно остановлен.");

    // Вызываем стандартную остановку
    await base.StopAsync(cancellationToken);
}
-----------------------------------------------------------------------------------
------------------------------------------------------------------------------------
// Etalon
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    SetupIncomingQuotesProcessing(stoppingToken);
    _logger.LogInformation("Publisher Service запущен. Ожидаем котировки...");

    await RunQuotePublicationLoop(stoppingToken);
}
private async Task RunQuotePublicationLoop(CancellationToken stoppingToken)
{
    var symbols = new[] { "AAPL", "GOOGL", "MSFT", "AMZN", "TSLA" };

    while (!stoppingToken.IsCancellationRequested)
    {
        try
        {
            var quote = GenerateRandomQuote(symbols);
            await PublishQuoteAsync(quote, stoppingToken);
            UpdateAndLogPublicationStats();
            await Task.Delay(TimeSpan.FromMilliseconds(500), stoppingToken);
        }
        catch (OperationCanceledException)
        {
            _logger.LogInformation("Публикация котировок прервана по запросу остановки.");
            break;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при публикации котировки");
            break;
        }
    }

    _logger.LogInformation("Publisher завершил публикацию. Всего: {Count}", _publishedCount);
    _channel.PublisherToSubscriber.Complete();
}
----------------------------------------------------------------------------------