Background Services: IHostedService, BackgroundService?

public sealed class CacheWarmupService(IServiceScopeFactory scopes, CatalogCache cache) : IHostedService
{
    public async Task StartAsync(CancellationToken ct)
    {
        await using var scope = scopes.CreateAsyncScope();
        var db = scope.ServiceProvider.GetRequiredService<ShopDbContext>();
        cache.Load(await db.Categories.AsNoTracking().ToListAsync(ct));     // приложение стартует после загрузки
    }
    public Task StopAsync(CancellationToken ct) => Task.CompletedTask;
}

public sealed class ExpiredReservationsCleaner(
    IServiceScopeFactory scopes, TimeProvider clock, ILogger<ExpiredReservationsCleaner> log) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromMinutes(1), clock);   // не накапливает «пропущенные» тики

        do
        {
            try
            {
                await using var scope = scopes.CreateAsyncScope();                 // новый скоуп на итерацию
                var db = scope.ServiceProvider.GetRequiredService<ShopDbContext>();
                var removed = await db.Reservations
                    .Where(r => r.ExpiresAt < clock.GetUtcNow())
                    .ExecuteDeleteAsync(stoppingToken);
                if (removed > 0) log.LogInformation("Удалено {Count} просроченных резервов", removed);
            }
            catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
            {
                break;                                                             // штатная остановка
            }
            catch (Exception ex)
            {
                log.LogError(ex, "Ошибка очистки резервов");                       // не роняем сервис из-за одной итерации
            }
        }
        while (await timer.WaitForNextTickAsync(stoppingToken));
    }
}

builder.Services.AddHostedService<ExpiredReservationsCleaner>();

public sealed class OrderEventsConsumer(IConnection rabbit, IServiceScopeFactory scopes, ILogger<OrderEventsConsumer> log) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await using var channel = await rabbit.CreateChannelAsync(cancellationToken: stoppingToken);
        await channel.BasicQosAsync(0, 16, false, stoppingToken);
        var consumer = new AsyncEventingBasicConsumer(channel);
        consumer.ReceivedAsync += async (_, ea) =>
        {
            await using var scope = scopes.CreateAsyncScope();
            var handler = scope.ServiceProvider.GetRequiredService<IOrderEventHandler>();
            try { await handler.HandleAsync(ea.Body, stoppingToken); await channel.BasicAckAsync(ea.DeliveryTag, false); }
            catch (Exception ex) { log.LogError(ex, "Ошибка обработки"); await channel.BasicNackAsync(ea.DeliveryTag, false, requeue: false); }
        };
        await channel.BasicConsumeAsync("order-events", autoAck: false, consumer, stoppingToken);
        await Task.Delay(Timeout.Infinite, stoppingToken);          // ждать до остановки
    }
}