Background Services

public class EmailQueueProcessor : BackgroundService {
    protected override async Task ExecuteAsync(CancellationToken stoppingToken) {
        while (!stoppingToken.IsCancellationRequested) {
            await ProcessQueueAsync();
            await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
        }
    }
}

// Registration
builder.Services.AddHostedService<EmailQueueProcessor>();

Common follow-ups: What's the difference between BackgroundService and implementing IHostedService directly?;How does the host handle exceptions thrown inside ExecuteAsync?

protected override async Task ExecuteAsync(CancellationToken stoppingToken) {
    while (!stoppingToken.IsCancellationRequested) {
        try {
            await DoWorkAsync(stoppingToken);
            await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken);
        } catch (OperationCanceledException) {
            break;  // expected during shutdown
        }
    }
}

Common follow-ups: How do you configure the shutdown grace period (ShutdownTimeout)?;What happens if ExecuteAsync doesn't respect cancellation at all?

public class OrderProcessor : BackgroundService {
    private readonly IServiceScopeFactory _scopeFactory;
    public OrderProcessor(IServiceScopeFactory scopeFactory) => _scopeFactory = scopeFactory;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken) {
        while (!stoppingToken.IsCancellationRequested) {
            using var scope = _scopeFactory.CreateScope();
            var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
            await ProcessPendingOrdersAsync(db);
            await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
        }
    }
}

Common follow-ups: What error occurs if you try injecting a scoped DbContext directly into a BackgroundService constructor?;How often should you create a new scope -- per iteration or per item processed?

protected override async Task ExecuteAsync(CancellationToken stoppingToken) {
    while (!stoppingToken.IsCancellationRequested) {
        try {
            await ProcessBatchAsync();
        } catch (Exception ex) {
            _logger.LogError(ex, "Batch processing failed, will retry next cycle");
        }
        await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
    }
}

Common follow-ups: What is the BackgroundServiceExceptionBehavior option added in .NET 6?;How do you get alerted when a background service has stopped unexpectedly?

public class MyLifecycleService : IHostedLifecycleService {
    public Task StartingAsync(CancellationToken ct) { /* before StartAsync */ return Task.CompletedTask; }
    public Task StartAsync(CancellationToken ct) { /* main start logic */ return Task.CompletedTask; }
    public Task StartedAsync(CancellationToken ct) { /* after all StartAsync calls */ return Task.CompletedTask; }
    // ... StoppingAsync, StopAsync, StoppedAsync similarly
}

Common follow-ups: Why was this added instead of relying purely on StartAsync/StopAsync ordering?;How does this interact with multiple hosted services registered in the same app?

dotnet new worker -n MyWorkerService

// Program.cs in a Worker Service template
var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddHostedService<Worker>();
var host = builder.Build();
host.Run();

Common follow-ups: When would you add a BackgroundService to a web app instead of a separate Worker Service?;How does resource isolation differ between the two deployment models?

protected override async Task ExecuteAsync(CancellationToken stoppingToken) {
    using var timer = new PeriodicTimer(TimeSpan.FromMinutes(5));
    while (await timer.WaitForNextTickAsync(stoppingToken)) {
        await RunScheduledJobAsync();
    }
}

Common follow-ups: How does WaitForNextTickAsync behave if the previous tick's work takes longer than the interval?;What happens to PeriodicTimer when disposed mid-wait?

builder.Services.AddHostedService<EmailQueueProcessor>();
builder.Services.AddHostedService<CacheWarmupService>();
builder.Services.AddHostedService<MetricsCollectorService>();
// All three run concurrently, independently, for the app's lifetime

Common follow-ups: Does the order of AddHostedService calls guarantee start order?;How would you make one hosted service wait for another to finish starting?

var channel = Channel.CreateBounded<EmailMessage>(capacity: 100);
builder.Services.AddSingleton(channel.Writer);
builder.Services.AddSingleton(channel.Reader);
builder.Services.AddHostedService<EmailSenderService>();

public class EmailSenderService : BackgroundService {
    protected override async Task ExecuteAsync(CancellationToken ct) {
        await foreach (var message in _reader.ReadAllAsync(ct)) {
            await SendEmailAsync(message);
        }
    }
}

Common follow-ups: What happens when a bounded channel is full and a producer tries to write?;How does this pattern compare to using an external message queue like RabbitMQ?

protected override async Task ExecuteAsync(CancellationToken stoppingToken) {
    var schedule = CronExpression.Parse("0 2 * * *");  // 2 AM daily, via Cronos
    while (!stoppingToken.IsCancellationRequested) {
        var next = schedule.GetNextOccurrence(DateTimeOffset.UtcNow);
        var delay = next.Value - DateTimeOffset.UtcNow;
        await Task.Delay(delay, stoppingToken);
        await RunNightlyReportAsync();
    }
}

Common follow-ups: When should you reach for Quartz.NET or Hangfire instead of hand-rolling scheduling?;How do you handle a missed scheduled run if the app was down at the scheduled time?