Background services and queues

A hosted service is code the host starts with the app and stops with it. IHostedService has StartAsync and StopAsync; the BackgroundService base class implements both and leaves you one method:

public class EmailSender(Channel<Email> queue, IServiceScopeFactory scopes,
                         ILogger<EmailSender> logger) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await foreach (var email in queue.Reader.ReadAllAsync(stoppingToken))
        {
            using var scope = scopes.CreateScope();
            var smtp = scope.ServiceProvider.GetRequiredService<ISmtpClient>();
            await smtp.SendAsync(email, stoppingToken);
        }
    }
}

builder.Services.AddSingleton(Channel.CreateBounded<Email>(1000));
builder.Services.AddHostedService<EmailSender>();

AddHostedService registers the service as a singleton, which is why it opens a scope for each unit of work rather than taking scoped services in its constructor. stoppingToken is cancelled when the host begins shutting down; the host then waits for ExecuteAsync to finish, up to a configurable shutdown timeout (HostOptions.ShutdownTimeout).

The queue

System.Threading.Channels is an in-process producer/consumer queue built for this. An endpoint writes, the background service reads, and the request returns without waiting for the slow work.

A bounded channel caps memory. Its FullMode decides what a write does when the channel is full: Wait (the default; WriteAsync waits and TryWrite returns false), DropOldest, DropNewest or DropWrite. The second example writes three items into a real channel of capacity 2 in each mode.

Work in a channel lives in memory: a crash or a deployment loses it, so work that must not be lost belongs in a durable queue or an outbox table.

Startup runs your method until its first await

On .NET 9, BackgroundService.StartAsync calls ExecuteAsync and returns when that method first yields. Everything before the first real await runs synchronously, during startup, before the next hosted service starts and before the server accepts requests. An exception thrown there comes back from StartAsync itself, so the app fails to start. The model below plays the host and an ExecuteAsync with a synchronous warm-up.

A long synchronous warm-up at the top of ExecuteAsync therefore delays the whole app. Start with an await, or move the blocking work into Task.Run.

Failure and shutdown

Since .NET 6, an unhandled exception escaping ExecuteAsync stops the host by default (BackgroundServiceExceptionBehavior.StopHost); set HostOptions.BackgroundServiceExceptionBehavior to Ignore and the host logs the exception and keeps running without that service. Catch and log per item inside the loop so one bad message does not take down the process. For periodic work, PeriodicTimer with WaitForNextTickAsync(stoppingToken) avoids overlapping runs.

Common mistakes

• Injecting a DbContext into the hosted service's constructor: a captive dependency, since the service is a singleton.
• Ignoring stoppingToken. Shutdown then waits for the timeout and the work is cut off anyway.
• Running a scheduled job in a hosted service on every instance of a scaled-out app. Each instance runs it, so the job runs N times unless something coordinates them.
• Treating DropWrite as safe. TryWrite still returns true, so the caller never learns the item was discarded.

What interviewers ask

• A queue (Channel) plus a ; durability trade-offs; never with request-scoped services.