# Usługи в ASP.NET Core - Part 1: Дослідження

<!--category-- ASP.NET Core, IHostedService, BackgroundService, Hangfire -->
<datetime class="hidden">2025-11-27T09:00</datetime>

Кожна сучасна веб-аplikaція має роботу, яка повинна:' не блокувати HTTP-запросу — відправляти електронні листи M SK2 обробляти файли МSK3 синхронізувати з зовнішними службами `IHostedService` implements to sophisticated frameworks like Hangfire. В цій першій частині ми , дослідимо фундаментальні шаблони і коли використовувати кожен з них

# Введение

Confession; Мені подобаються Background Services a LOTM SK1 цей сайт (a BLOG site МSK3 має більше половини M SK4 дюжину з них займаються серйозними фоновими завданнями , але, як і все, у них є певні ODDITIES та практики, які зрозуміють вам їх набагато приємніше використовувати
Бюро背景ів - невідомі герої сучасних веб-пристосувань. Podczas, як ваші контролери виконують HTTP-запити на передньому плані , Бюro背景ів спокійно обробляє загасовані електронні листи МSK2 індикаторний контент для пошуку MSC3 перевіряє зовнішні API M SK4 прибирає тимчасові файли , і виконує безліч інших завдань, які інакше заблокували б pipeline ваших запитів MRK6

В цих двох серіях, МСК0, МSK1 і МСК2, ми дослідимо різні підходи до введення базових послуг у ASP, ., NET Core та , збудованих `IHostedService` і `BackgroundService` абстракції до більш складних рішень, як-от Hangfire. У частині M SK1 ми ' проаналізуємо фундаментальні підходи та їхні характеристики. В [Частина 2](/blog/background-services-in-aspnetcore-part2), ми ' зануримося у реальні МSK2 інтерфейси світу з кодової бази виробництва

> **Важливо:** Ми звернемо особливу увагу на управління життєвим циклом, зокрема, часто занедбаних `StopAsync` метод,, де багато розробників стикаються з криптичними винятками, коли їх застосування закриваються

[TOC]

# Навіщо базові послуги?

Перед тим, як зануритися в " як МSK1 дозволити МSK2s коротко подумайте про " чому \ ." \ Навігаційні послуги дозволять вам

1. **Повільні операції відряду** - Не змушуйте користувачів чекати, поки ви надсилаєте електронні листи чи генеруєте PDF
2. **Запланувати повторювані завдання** - Зачистка старих записів щовечора в МSK1
3. **Кої processу** - Передавати повідомлення від каналів або брокерів
4. **Бачити зовнішній стан** - API для опитування або файлові системи для спостереження за змінами
5. **Координувати складні робочі потоки** - Управляйте багатьма proceduraми, що тривають хвилини або години

ASP.NET Core надає кілька підходів для втілення цих послуг

# Історічний контекст: Чому тепер дають доступ до базових послуг

У давні часи running background work в веб-приложениї зазвичай вважався поганою ідеєю.

Це не просто вантаж - це була чудернацька мудрість - це було засновано на реальних технічних обмеженнях

## Епоха Кора

Ранні веб-сервери ( і, чесно кажучи, зараз МSK1 МSK2 дешеві ' А Azure-сервіси **pojedyncze-core або подвійні-core процесори**. Якщо ви запустили CPU- інтенсивний фоновий задачіM SK2 він безпосередньо конкурував з веб-запитими для того ж ядра :

```
Single Core (2005):
┌─────────────────────┐
│  Background Task    │  ← Uses 80% CPU
│  (80% of core)      │
├─────────────────────┤
│  Web Requests       │  ← Only 20% left!
│  (20% of core)      │  ← Slow responses
└─────────────────────┘
```

Результат: Ваша веб-сторінка стала повільнею, коли запустили роботу на фоніM SK1

## Стридж-pool голодування

Класичний ASP.NET **thread-per-request**. Коллекция потоків була відносно маленькою

```csharp
// Classic ASP.NET (2008)
ThreadPool.QueueUserWorkItem(_ =>
{
    // This steals a thread from the pool!
    ProcessLongRunningTask();
});

// Meanwhile, web requests are queued waiting for threads
// HTTP 503 Service Unavailable
```

## Переробка Pool Application IIS

IIS агрессивно перероблятиме додатки. (заново запустити вашу програму) на основі обмежень пам 'ятіM SK2 підрахунки запитів , або वेळापत ’ रकMSC4 оперативна робота буде знищена всередині

```
00:00 - Background import starts (2 hour task)
02:00 - IIS recycles app pool (scheduled)
      - Background task killed
      - Work lost, must start again
```

## Ограничений Async/Отримаємо підтримку

До того, як .NET 4.5 МSK2 асинхове програмування було МSK3 відносно M) боляче МСК5 Задачи на фоні часто непотрібно блокували потоки МК6

```csharp
// Pre-async (2008)
void ProcessEmails()
{
    foreach (var email in GetEmails())
    {
        smtp.Send(email);  // Blocks thread for 500ms per email
    }
}
// 100 emails = 50 seconds of blocked thread time
```

## Що змінило епоху сучасності?

На сьогодні

### 1. МультиM SK1 Кора доступна

Економіка змінилася. ХлобаловіVM з багатьма ядрами reasonably priced , and bare metal servers are surprisingly cheapM SK2 This blog runs on a dedicated 8- core server that costs less than a comparable Azure VMMSC4and I get all those cores to myselfMska5 no noisy neighboursM Ska6 A background task on one core doesn’ t significantly impact web requests on other coreMSKA8

```
8-Core Server (2024):
Core 1: ████████████████████ Web Requests
Core 2: ████████████████████ Web Requests
Core 3: ████████████████████ Web Requests
Core 4: ████████████████████ Web Requests
Core 5: ████████████████████ Background Task ← Isolated
Core 6: ████████████████████ Background Task
Core 7: ████████████████████ Background Task
Core 8: ████████████████████ Background Task
```

### 2. Асинк / Будь-де чекати

.NET робить асинк-програмування банальним . Задачі на фоні можуть чекати на I/O без блокування потоківM SK3

```csharp
// Modern async (2024)
async Task ProcessEmailsAsync(CancellationToken ct)
{
    await foreach (var email in GetEmailsAsync(ct))
    {
        await smtp.SendAsync(email, ct);  // Doesn't block thread!
    }
}
// 100 emails processed efficiently, thread returns to pool during I/O
```

### 3. Кращий процес хостингу

- [**Докер**](https://www.docker.com/) - Посередні послуги у контейнерах не переробляються
- [**Кубернеті**](https://kubernetes.io/) - Правильний гнучкий підключення з `SIGTERM`
- [**систематично**](https://systemd.io/) - Linux-сервіси, які можуть відпочати роботу надійно
- **Услуги Windows** - Правильний довгий МSK1модель процесу

### 4. Канали та сучасні примітиви

.NET тепер має першу підтримку klasy - для синхронного програмування з [`System.Threading.Channels`](https://learn.microsoft.com/en-us/dotnet/core/extensions/channels):

```csharp
// System.Threading.Channels
var channel = Channel.CreateBounded<Email>(100);

// Producer (web request)
await channel.Writer.WriteAsync(email);  // Fast, non-blocking

// Consumer (background service)
await foreach (var email in channel.Reader.ReadAllAsync())
{
    await ProcessAsync(email);  // Efficient, async
}
```

### 5. Ограничення ресурсів та класи

Сучасні оркеструвальники контейнерів дозволяють вам **обмеження використання ресурсів**:

```yaml
# Kubernetes resource limits
resources:
  limits:
    cpu: "500m"        # Background task can't use more than 0.5 CPU
    memory: "512Mi"    # Or more than 512 MB RAM
```

Це означає, що завдання на фоні може не голодувати вашого веб-ґатунку

Питання більше не """, а "" МSK2 "".**Чи варто нам**МСК0 МиМSK1 розглянемо це рішення в розділі " Коли не використовувати базові послугиММК3 пізнішеММСК4

# Вбудовані параметри

## IHostedService: Фонд

У своєму ядре - МСК0 - кожен фоновий сервіс ASP - МSK1 - NET Core [`IHostedService`](https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.ihostedservice). Цей інтерфейс дуже простий

```csharp
public interface IHostedService
{
    Task StartAsync(CancellationToken cancellationToken);
    Task StopAsync(CancellationToken cancellationToken);
}
```

Це – МСК0, це – МSK1. Два способи: МСК2 `StartAsync` з 'являється, коли запущена ваша програма, і `StopAsync` коли він закривається

Зарегистрируйтесь в `Program.cs`:

```csharp
builder.Services.AddHostedService<MyBackgroundService>();
```

Ось візуалізація життєвого циклу

```mermaid
graph LR
    A[Application Starts] --> B[StartAsync Called]
    B --> C[Service Running]
    C --> D[Application Shutting Down]
    D --> E[StopAsync Called]
    E --> F[Application Stopped]

    style A stroke:#059669,stroke-width:3px,color:#10b981
    style C stroke:#2563eb,stroke-width:3px,color:#3b82f6
    style F stroke:#dc2626,stroke-width:3px,color:#ef4444
```

### StartAsync: Синхронний проти асинхронного старту

Критична рішення при втіленні `IHostedService` чи ваша `StartAsync` метод повинен блокувати або повернутися негайно.

**Синхронний (блокуванняM SK1 запуск:**

```csharp
public class BlockingStartService : IHostedService
{
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // This blocks application startup until complete
        await InitializeDatabaseAsync(cancellationToken);
        await LoadConfigurationAsync(cancellationToken);

        // Only now will the application continue starting
    }

    public Task StopAsync(CancellationToken cancellationToken)
        => Task.CompletedTask;
}
```

**Асинхронний (неможливий-блокуванняM SK2початокMSC3**

```csharp
public class NonBlockingStartService : IHostedService
{
    private Task _backgroundTask;
    private readonly CancellationTokenSource _cts = new();

    public Task StartAsync(CancellationToken cancellationToken)
    {
        // Start background work but return immediately
        _backgroundTask = Task.Run(async () =>
        {
            // Give other services time to initialise
            await Task.Delay(TimeSpan.FromSeconds(5), _cts.Token);
            await DoLongRunningWorkAsync(_cts.Token);
        }, _cts.Token);

        return Task.CompletedTask;
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        _cts.Cancel();
        await _backgroundTask; // Wait for completion
    }
}
```

**Коли використовувати кожен підхід:**

- **Блокування:** Коли служба повинна завершити інisiaлізацію перед тим, як програма зможе виконувати завдання. (eM SK1g., завантаження критичної конфігурації
- **Неможливе-блокуванняM SK1** Коли служба може inicialізуватися в фоні, тоді як інші сервіси запускаються (eM SK1g., indeksуючи наявний контент , синхронізація з зовнішніми службамиMSC4

### StopAsync: Зазвичайний провал

Тут' це місце, де все стає цікавішим — і де багато розробників зіштовхуються з проблемами МSK2 Коли ваша програма закривається `StopAsync` на всіх об 'єднаних службах. У вас є обмежене вікно M SK1по замовчуванню МSK2секунди МSK3 для гарного прибирання. Ви можете розширити це в `Program.cs`:

```csharp
builder.Services.Configure<HostOptions>(options =>
{
    options.ShutdownTimeout = TimeSpan.FromSeconds(30);
});
```

**Найчастіша помилка:**

```csharp
public class BrokenService : IHostedService
{
    private readonly Channel<string> _channel = Channel.CreateUnbounded<string>();
    private Task _processingTask;

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _processingTask = ProcessMessagesAsync();
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        // WRONG: The channel is still open, ProcessMessagesAsync
        // will hang on WaitToReadAsync forever!
        return Task.CompletedTask;
    }

    private async Task ProcessMessagesAsync()
    {
        // This will never exit because the channel is never completed
        await foreach (var message in _channel.Reader.ReadAllAsync())
        {
            await ProcessAsync(message);
        }
    }
}
```

Коли ви запускаєте цю службу і зупиняєте свою програму, ви побачите такі помилки як:

```
Unable to cast object of type 'TaskCompletionSource`1[System.Threading.Tasks.VoidTaskResult]' to type 'System.Threading.Tasks.Task'
```

Або програма просто зачепиться на час відключення, перш ніж forcefully terminating.

**Правильний підхід:**

```csharp
public class CorrectService : IHostedService
{
    private readonly Channel<string> _channel = Channel.CreateUnbounded<string>();
    private readonly CancellationTokenSource _cts = new();
    private Task _processingTask;

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _processingTask = ProcessMessagesAsync(_cts.Token);
        return Task.CompletedTask;
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        // CORRECT: Signal cancellation and complete the channel
        await _cts.CancelAsync();
        _channel.Writer.Complete();

        try
        {
            // Wait for processing to finish or for the shutdown timeout
            await Task.WhenAny(_processingTask,
                Task.Delay(Timeout.Infinite, cancellationToken));
        }
        catch (OperationCanceledException)
        {
            // Expected when shutdown timeout is reached
        }
    }

    private async Task ProcessMessagesAsync(CancellationToken token)
    {
        await foreach (var message in _channel.Reader.ReadAllAsync(token))
        {
            try
            {
                await ProcessAsync(message);
            }
            catch (OperationCanceledException)
            {
                // Shutdown requested, exit gracefully
                break;
            }
        }
    }
}
```

**Ключові моменти для правильного втілення StopAsync:**

1. **Anulування сигналу** - Використовуйте `CancellationTokenSource` і відкидати його
2. **Завершити канали** - Якщо ви `Writer.Complete()`
3. **Почекайте на завдання на фоні** - Використовувати `Task.WhenAny` з символом anulації замкнутості
4. **Рух operationCanceledException** - Це очікувано і має бути виявлено
5. **Не викидати винятків** - Винятки в `StopAsync` може призвести до непередбачуваного поведінки

## Базова послуга: Удобна базова клас

Письмо `IHostedService` інсталяції можуть бути повторюваними. Вам завжди потрібна фонова задача [`BackgroundService`](https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.backgroundservice) керує цим котлярним панелем для вас:

```csharp
public abstract class BackgroundService : IHostedService, IDisposable
{
    private Task _executeTask;
    private CancellationTokenSource _stoppingCts;

    protected abstract Task ExecuteAsync(CancellationToken stoppingToken);

    public virtual Task StartAsync(CancellationToken cancellationToken)
    {
        _stoppingCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        _executeTask = ExecuteAsync(_stoppingCts.Token);
        return Task.CompletedTask;
    }

    public virtual async Task StopAsync(CancellationToken cancellationToken)
    {
        if (_executeTask == null) return;

        try
        {
            _stoppingCts.Cancel();
        }
        finally
        {
            await Task.WhenAny(_executeTask, Task.Delay(Timeout.Infinite, cancellationToken));
        }
    }

    public virtual void Dispose()
    {
        _stoppingCts?.Cancel();
    }
}
```

Ви просто реалізуєте `ExecuteAsync` і дозволити базовому класу керувати водопроводом:

```csharp
public class SimpleBackgroundService : BackgroundService
{
    private readonly ILogger<SimpleBackgroundService> _logger;

    public SimpleBackgroundService(ILogger<SimpleBackgroundService> logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Service starting");

        // Wait for app to finish starting
        await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                await DoWorkAsync(stoppingToken);
                await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
            }
            catch (OperationCanceledException)
            {
                // Shutdown requested
                break;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error in background service");
            }
        }

        _logger.LogInformation("Service stopping");
    }

    private async Task DoWorkAsync(CancellationToken token)
    {
        _logger.LogInformation("Doing work...");
        // Your actual work here
        await Task.Delay(1000, token);
    }
}
```

### Коли використовувати BackgroundService проти IHostedService

**Використовувати `BackgroundService` коли:**

- Вам потрібен довгий -забігаючий фоновий цикл
- Ви хочете прості періодичні виконання
- Вам не потрібно контролювати `StartAsync`/`StopAsync` набір часу

**Використовувати `IHostedService` коли:**

- Потрібно контролювати саме те, що відбувається `StartAsync` проти роботи на фоні
- Ви' створюєте обладначі подій або спостерігачі, а не постійному циклу
- Вам потрібно координувати роботу з іншими службами під час запуску

# Розвинена: Координація запуску

Інколи вам потрібні послуги, щоб чекати одне на одного.. Наприклад,

Ось pattern для координації запуску сервісу

```csharp
public interface IStartupCoordinator
{
    void RegisterService(string serviceName);
    void SignalReady(string serviceName);
    bool IsServiceReady(string serviceName);
    Task WaitForServiceAsync(string serviceName, CancellationToken cancellationToken = default);
    Task WaitForAllServicesAsync(CancellationToken cancellationToken = default);
}

public class StartupCoordinator : IStartupCoordinator
{
    private readonly ConcurrentDictionary<string, TaskCompletionSource> _services = new();
    private readonly ILogger<StartupCoordinator> _logger;

    public void RegisterService(string serviceName)
    {
        _services.TryAdd(serviceName, new TaskCompletionSource());
    }

    public void SignalReady(string serviceName)
    {
        if (_services.TryGetValue(serviceName, out var tcs))
        {
            tcs.TrySetResult();
            _logger.LogInformation("{Service} is ready", serviceName);
        }
    }

    public async Task WaitForServiceAsync(string serviceName, CancellationToken ct = default)
    {
        if (_services.TryGetValue(serviceName, out var tcs))
        {
            await tcs.Task.WaitAsync(ct);
        }
    }

    public async Task WaitForAllServicesAsync(CancellationToken ct = default)
    {
        await Task.WhenAll(_services.Values.Select(tcs => tcs.Task)).WaitAsync(ct);
    }
}
```

Використовування в службі:

```csharp
public class DependentService : IHostedService
{
    private readonly IStartupCoordinator _coordinator;
    private readonly ILogger<DependentService> _logger;

    public DependentService(
        IStartupCoordinator coordinator,
        ILogger<DependentService> logger)
    {
        _coordinator = coordinator;
        _logger = logger;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // Wait for another service to be ready
        await _coordinator.WaitForServiceAsync("MarkdownProcessor", cancellationToken);

        _logger.LogInformation("Dependencies ready, starting work");

        // Do your work...

        // Signal you're ready for services that depend on you
        _coordinator.SignalReady("DependentService");
    }

    public Task StopAsync(CancellationToken cancellationToken)
        => Task.CompletedTask;
}
```

Ця модель стає особливо корисною, коли ви маєте багато базових послуг з взаємозалежністю.

# Розповсюджена координація з Redis

Координатор запуску працює в рамках одного прикладного випадку. Але що трапляється, коли ви масштабуєте один до кількох instanційM SK1 Ви не хочете ' хочете, щоб три instanції працювали одночасно з тим же запланованим завданням

[Рідіс](https://redis.io/) надає просте рішення: використовувати флаги M SK1 ключі) для координації того, хто робить що

## Прості вибори лідера

```csharp
public class DistributedBackgroundService : BackgroundService
{
    private readonly IConnectionMultiplexer _redis;
    private readonly ILogger<DistributedBackgroundService> _logger;
    private readonly string _instanceId = Guid.NewGuid().ToString();
    private const string LeaderKey = "background:newsletter:leader";

    public DistributedBackgroundService(
        IConnectionMultiplexer redis,
        ILogger<DistributedBackgroundService> logger)
    {
        _redis = redis;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var db = _redis.GetDatabase();

        while (!stoppingToken.IsCancellationRequested)
        {
            // Try to become the leader (SET NX with expiry)
            var acquired = await db.StringSetAsync(
                LeaderKey,
                _instanceId,
                TimeSpan.FromMinutes(5),
                When.NotExists);

            if (acquired)
            {
                _logger.LogInformation("This instance is the leader, running task");

                try
                {
                    await DoScheduledWorkAsync(stoppingToken);
                }
                finally
                {
                    // Release leadership
                    await db.KeyDeleteAsync(LeaderKey);
                }
            }
            else
            {
                var leader = await db.StringGetAsync(LeaderKey);
                _logger.LogDebug("Another instance ({Leader}) is the leader", leader);
            }

            await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
        }
    }
}
```

## Розділений замок для критичних секцій

Для завдань, які не повинні працювати одночасно між instancjami:

```csharp
public async Task ProcessWithLockAsync(CancellationToken cancellationToken)
{
    var db = _redis.GetDatabase();
    var lockKey = "locks:critical-task";
    var lockValue = _instanceId;

    // Try to acquire lock
    if (await db.LockTakeAsync(lockKey, lockValue, TimeSpan.FromMinutes(10)))
    {
        try
        {
            _logger.LogInformation("Lock acquired, processing...");
            await DoCriticalWorkAsync(cancellationToken);
        }
        finally
        {
            await db.LockReleaseAsync(lockKey, lockValue);
        }
    }
    else
    {
        _logger.LogDebug("Could not acquire lock, another instance is processing");
    }
}
```

## Коли використовувати розподілену координацію

- **Заплановані завдання** - Лише один випадок повинен надіслати щоденний бюллетень
- **Обробка черги з замовленням** - Упевнитись, що повідомлення обробляються в порядку
- **Ресурс- інтенсивні операції** - Захищати multiple instances from overwhelming an external API
- **Міграції в бази даних** - Лише один випадок повинен запускати міграції при запускі

Для більш складних сценаріїв (multiM SK1step jobs, надійний розклад по всіх рестартах ), візьміть до уваги Hangfire, який обробляє розподілене заблокування автоматично з його базою даних

# Коли НЕ використовувати базові послуги

До того, як ми зануримося в більш складні інструменти, такі як Hangfire, дозвольте' говорити про те, коли ви *shouldn't* використати базові послуги у головній веб-аplikaції.

## Потрібно розділити проект

Інформаційні служби, що запускаються в вашій веб-прикладі, поширюють ресурси з вашими HTTP-запросами.. Це може призвести до проблем:

### 1. Обговорення ресурсів

**Проблема:** Ваша база даних споживає значний CPU, пам 'ять, або зв' язки з базами данихM SK2

```csharp
// This will starve your web application
public class VideoTranscodingService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var video = await _queue.DequeueAsync();
            // This uses 100% of 4 CPU cores for 5 minutes
            await TranscodeVideoAsync(video);
        }
    }
}
```

**Коли веб-запити приходять під час транскодування, вони повільні, бо CPU зайняті**

**Рішення:** Переход до окремої робітничої служби:

```bash
# Your solution structure
/YourApp.Web          # ASP.NET Core web app - no background services
/YourApp.Worker       # .NET Worker Service - handles background work
/YourApp.Shared       # Shared models, interfaces
```

### 2. Різні вимоги до масштабування

**Проблема:** Ваші попередні роботи потребують різного масштабування, ніж ваш веб рівень.

- **Веб рівень:** Шкала для HTTP-траficу (можливо потребувати МSK1 інстанцій протягом дняM SK2 2 вночі)
- **Базова рівність:** Скала для глибини черги (можливо потребувати МSK1 інстанція зазвичай МSK2 20 при обробці пакету

Якщо вони в тому ж процесі, ви можете масштабувати їх неzależnie.

**Прикладний сценарій:**

```
09:00 - High web traffic, low background work → Need 10 web instances, 1 worker
14:00 - Newsletter time! Low web traffic, high background work → Need 2 web instances, 20 workers
```

Поміщання фонових послуг у веб-апцію означає, що вам ' потрібно запускати 20 веб інстанції тільки для того, щоб задовольнити newsletter

### 3. Незалежність від використання

**Проблема:** Ви хочете застосувати зміни в вебі без перезапускання базових послуг ( або навпакиM SK1

```csharp
// If this is in your web app, deploying a CSS change restarts the service
public class LongRunningImportService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        // This import takes 2 hours
        await ImportMillionsOfRecordsAsync(stoppingToken);
    }
}
```

Кожне застосування зупиняє введення. Переміщаємо його до окремої робітничої служби, яку ви застосовуєте самостійно.

### 4. Різні домена невдачі

**Проблема:** Баг у вашій фоновій службі скасує всю веб-програму.

```csharp
// This null reference exception crashes your web app
public class BuggyBackgroundService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        string value = null;
        // Unhandled exception - takes down the whole app
        await ProcessAsync(value.Length);
    }
}
```

Якщо фонова робота знаходиться в іншому процесі, вона може скасуватися і розпочати роботу, не впливаючи на веб-запити.

## Як спричинити фонові послуги

Коли ви вирішуєте розділити

### Опція 1: . NET Worker Service

Створити новий проект, використовуючи шаблон Служби робітників:

```bash
dotnet new worker -n YourApp.Worker
```

Структура:

```
/YourApp.Worker
  /Services
    VideoTranscodingService.cs
    EmailSenderService.cs
  /Program.cs
  /appsettings.json
```

Програму.csM SK1

```csharp
var builder = Host.CreateApplicationBuilder(args);

// Register your background services
builder.Services.AddHostedService<VideoTranscodingService>();
builder.Services.AddHostedService<EmailSenderService>();

// Share configuration with web app
builder.Services.Configure<VideoConfig>(
    builder.Configuration.GetSection("Video"));

// Share database context
builder.Services.AddDbContext<YourDbContext>(options =>
    options.UseNpgsql(builder.Configuration.GetConnectionString("Default")));

var host = builder.Build();
host.Run();
```

Розміщувати окремо:

```bash
# Web app on ports 80/443
/YourApp.Web → web-server-1, web-server-2, web-server-3

# Worker service doesn't listen on any port
/YourApp.Worker → worker-server-1, worker-server-2
```

### Опція 2: розділити проект з спільним чергою

Використовуйте чергу повідомлень, щоб відокремити веб і працівників:

```mermaid
graph LR
    A[Web App] --> B[Message Queue]
    B --> C[Worker 1]
    B --> D[Worker 2]
    B --> E[Worker N]

    style A stroke:#059669,stroke-width:3px,color:#10b981
    style B stroke:#2563eb,stroke-width:3px,color:#3b82f6
    style C stroke:#7c3aed,stroke-width:3px,color:#8b5cf6
    style D stroke:#7c3aed,stroke-width:3px,color:#8b5cf6
    style E stroke:#7c3aed,stroke-width:3px,color:#8b5cf6
```

Рабочие черги веб-приложений:

```csharp
// In your web controller
public class VideoController : ControllerBase
{
    private readonly IMessageQueue _queue;

    [HttpPost("upload")]
    public async Task<IActionResult> Upload(IFormFile video)
    {
        await _storage.SaveAsync(video);

        // Queue for processing - don't process in web app
        await _queue.PublishAsync(new VideoTranscodeJob
        {
            VideoId = video.Id,
            Priority = Priority.Normal
        });

        return Accepted(); // Return immediately
    }
}
```

Працівник споживає з черги:

```csharp
// In your worker service
public class VideoWorker : BackgroundService
{
    private readonly IMessageQueue _queue;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await foreach (var job in _queue.SubscribeAsync<VideoTranscodeJob>(stoppingToken))
        {
            await TranscodeAsync(job);
        }
    }
}
```

**Найпопулярніші варіанти черги повідомлень:**

- [**RabbitMQ**](https://www.rabbitmq.com/) - НайпопулярнішіM SK1 функція-багато
- [**А Azure Service Bus**](https://azure.microsoft.com/en-us/products/service-bus/) - Якщо ви на Azure
- [**АWS SQS**](https://aws.amazon.com/sqs/) - Якщо ви на AWS
- [**Редіс Streams**](https://redis.io/docs/data-types/streams/) - ПростішийM SK1 хороший для меншого розміру

### Опція 3: Множество спеціалізованих робітників

Для складних систем

```
/YourApp.Web              # HTTP requests only
/YourApp.EmailWorker      # Sends emails
/YourApp.VideoWorker      # Transcodes videos
/YourApp.ReportWorker     # Generates reports
/YourApp.Scheduler        # Runs scheduled jobs (Hangfire)
```

Кожен працівник може

- Скала незалежно
- Працювати незалежно
- Використовуйте різні ресурси (email workers needs SMTPM SK1 video worker needs GPU)
- Подібне стеження і попередження

## Коли зберігати подібні послуги в вашій веб-апці

Незважаючи на це, деякі сценарії абсолютно непогані для

### Легкі періодичні завдання

```csharp
// Fine to keep in web app
public class CacheWarmingService : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await _cache.WarmupAsync(); // Quick operation
            await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
        }
    }
}
```

### Слухачі подій

```csharp
// Fine to keep in web app
public class FileWatcherService : IHostedService
{
    // Reacts to events, doesn't consume significant resources
    private FileSystemWatcher _watcher;

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _watcher = new FileSystemWatcher("/config");
        _watcher.Changed += OnConfigChanged;
        _watcher.EnableRaisingEvents = true;
        return Task.CompletedTask;
    }
}
```

### Канал-Посадкова черга M SK1для неможливих-критичну роботуMSC3

```csharp
// Fine to keep in web app if work is quick and not critical
public class EmailQueueService : BackgroundService
{
    // Sends emails in background, but each email takes < 1 second
    // If the app restarts, losing a few queued emails is acceptable
}
```

### Координація запуску

```csharp
// Fine to keep in web app
public class WarmupService : IHostedService
{
    // Runs once at startup, then does nothing
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        await _database.WarmupConnectionPoolAsync();
        await _cache.LoadCriticalDataAsync();
    }
}
```

## Матрица прийняття рішень

| Характеристика МSK1 Утримка в веб-апліці МSK2 Перехід до робітничої служби |
|---------------|-----------------|------------------------|
| Використовування процесора на одну операцію
| Пам 'ять на одну операцію
МSK0 Частота | Периодічна МSK2 хвилини МСК3 години М СК4 M СК5 Неперервна або висока ССК6 частота \ М С К7
| Критичний | Некритичний МSK2критичний
МSK0 Продолжительность | Стори МSK2 Миті до годин |
| Скала з МSK1 Веб-траfic МSK2 Глубина черги праці |
| До прикладу | Отопування таємниці МSK2 перезавантаження конфігурації МSK3 Обробка відеозаписів

## Реальність- Світовий приклад : Блог-платформа

В блоговій платформі, код якої ми вивчаємо у частині 2:

**Залишена в веб-прикладі:**

- `MarkdownDirectoryWatcherService` - Легкий файловий годинник
- `UmamiBackgroundSender` - Краткий аналіз подій
- `EmailSenderHostedService` - Невеликий об 'єм , не МSK2 критичний
- `MarkdownReAddPostsService` - Начальник - ТількиM SK2 конфігурація МSK3 задіяна

**Чи варто переїхати на службу працівників, якщо масштаб зростає:**

- `BrokenLinkCheckerBackgroundService` - Зробляє багато HTTP запитів
- `SemanticIndexingBackgroundService` - Викликає зовнішній API для вмонтування

**Уже в окремому обслуживанні:**

- `Mostlylucid.SchedulerService` - Панель навігацій Hangfire і відправлення bulletinів

Це прагматичний підхід.

# Поза базовими принципами: Hangfire

В той час `IHostedService` і `BackgroundService` є чудовими для послуг, які ви маєте і контролюєте. [Постріл](https://www.hangfire.io/) прийти

 Хангфайр  надає:

- **Неперервні черги робіт** - Роботи, які виживають після запуску програми
- **Рекурентні роботи** - CronM SK1програмування
- **Панель інтерфейсу** - Подивіться, що running
- **Розповсюджене виконання** - Багато серверів можуть обробляти одну і ту ж чергу робіт
- **Автоматічні повторення** - Неисправні завдання автоматично відслідковуються з експоненційним відхиленням

Ось простий приклад:

```csharp
// In Program.cs
builder.Services.AddHangfire(config => config
    .UsePostgreSqlStorage(connectionString)
    .UseRecommendedSerializerSettings());

builder.Services.AddHangfireServer();

var app = builder.Build();

// Schedule recurring jobs
app.UseHangfireDashboard();
app.Services.GetRequiredService<IRecurringJobManager>()
    .AddOrUpdate<NewsletterService>(
        "send-daily-newsletter",
        x => x.SendDailyNewsletter(),
        Cron.Daily(17)); // 5 PM every day
```

Ваша послуга - це лише нормальна клас.

```csharp
public class NewsletterService
{
    private readonly IEmailService _emailService;
    private readonly ISubscriberRepository _subscribers;

    public NewsletterService(
        IEmailService emailService,
        ISubscriberRepository subscribers)
    {
        _emailService = emailService;
        _subscribers = subscribers;
    }

    public async Task SendDailyNewsletter()
    {
        var subscribers = await _subscribers.GetDailySubscribersAsync();

        foreach (var subscriber in subscribers)
        {
            await _emailService.SendNewsletterAsync(subscriber);
        }
    }
}
```

Ручки вогню:

- Упевнитись, що робота відбуватиметься в запланованому часі
- Знову спробувати, якщо це не вдасться
- Сохранени історії страти
- Дозволяти налагодити панель для перевірки всього

```mermaid
graph TD
    A[Hangfire Server] --> B{Check Schedule}
    B -->|Job Due| C[Dequeue Job]
    C --> D[Execute Job Method]
    D -->|Success| E[Mark Complete]
    D -->|Failure| F[Retry with Backoff]
    F --> G{Max Retries?}
    G -->|No| C
    G -->|Yes| H[Mark Failed]
    E --> I[Update Dashboard]
    H --> I
    I --> B

    style A stroke:#059669,stroke-width:3px,color:#10b981
    style D stroke:#2563eb,stroke-width:3px,color:#3b82f6
    style E stroke:#059669,stroke-width:3px,color:#10b981
    style H stroke:#dc2626,stroke-width:3px,color:#ef4444
```

**Коли використовувати Hangfire:**

- Вам потрібні тривалі черги робіт, які переживуть рестарт
- Ви хочете, щоб панель з настроями моніторувала і ручно запускала завдання
- Потрібно розповсюджувати роботу на багатьох серверах
- Ви хочете зробити збудовану - логіку повторного спроби і подолання проблем
- Вам потрібне cron-stil планування повторюваних завдань

**Коли користуватись IHostedService/BackgroundService :**

- Потрібно добре контролювати життєвий цикл служби
- Ваша служба повинна реагувати на події в реальному часі-
- Ви хочете мінімізувати залежності
- Ви створюєте просту періодичну задачу, яка не потребує тривалості

# Інші варіанти

У той час, як Hangfire популярний, існують інші бібліотеки, які варто взяти до увагиM SK1

[**Кварц.NET**](https://www.quartz-scheduler.net/):

- Мова йде про більш гнучке планування, ніж у випадку з Hangfire.
- Obsługа виражень cron і календару-, що базується на розкладі
- Може залишатися на багатьох базах даних
- Складніший інтерфейс, але потужніший

[**Масове переміщення**](https://masstransit.io/)/[**NServiceBus**](https://particular.net/nservicebus):

- Полне-втілення автобусу повідомлень
- Краще для розподілених систем та мікрослужб
- Підтримка сага ( довгих -швидких операційних потоківM SK2
- Швидша кривая навчання

[**Функції Azure**](https://azure.microsoft.com/en-us/products/functions/)/[**АWS Ламбда**](https://aws.amazon.com/lambda/):

- Якщо ви - МСК0 - знаходитесь в хмарі, - МSK1 - маєте на увазі безсерверний
- платити за виконання, а не тримати службу на місці
- Автоматичне масштабування
- Невелика затримка для холодного старту

# Підсумок

У частині "1," ми МSK1 застосували фундаментальні підходи до базових послуг в ASP

1. **Услуга IHosted** - Основа МSK1 maksimalа гнучкість
2. **Обслуживание на тлі** - Удобна базовий клас для довгих ланцюгів
3. **Координація запуску** - Дозволяти службам чекати одне на одного
4. **Розповсюджена координація** - Використовуючи Redis для багатьох сценаріїв МSK1
5. **Постріл** - Коли вам потрібні тривалі роботи та складне планування

Найважливіші уроки

- **Завершити канали і anulувати символи в StopAsync**
- **вирішити, чи StartAsync повинен блокувати або негайно повернутися**
- **Рух operationCanceledException граціозно**
- **Використовуйте задачу.WhenAny з символом вимкнений , щоб поважати вимкнення**

В [Частина 2](/blog/background-services-in-aspnetcore-part2), ми ' перевіримо реальні МSK2 світові втілення з виробничої блогової платформи

- Файлові системні спостерігачі, які синхронизують файли відмітки до бази даних
- Відправники електронної пошти з політиками повторного спробування та блокувальниками схеми
- Кільця подій, що вимагають пакету
- Семантичні пошукові індекси, які обробляють контент асинхронно
- Пошкоджені перевірники зв 'язків, які периодически підтверджують зовнішні URL

Ці приклади демонструють візерунки з частини 1 в дії ,, включаючи модель координації запуску і правильне подолання замкнутості .

# Дальне читання

- [Microsoft Docs: Задачи на фоні з домашними послугами](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/host/hosted-services)
- [Документація Hangfire](https://docs.hangfire.io/)
- [Канали в C#](https://learn.microsoft.com/en-us/dotnet/core/extensions/channels)
- [Документація Quartz.NET](https://www.quartz-scheduler.net/)
- [StackExchange.Redis](https://stackexchange.github.io/StackExchange.Redis/) - Redis-клиент для .NET