Background Tasks & Hosted Services

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

builder.Services.AddHostedService<QueueProcessor>();

Common follow-ups: How does the host handle exceptions thrown inside ExecuteAsync?;What's the difference between BackgroundService and a dedicated Worker Service project?

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 exception 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 DoWorkAsync(stoppingToken);
            await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken);
        } catch (OperationCanceledException) {
            break;  // expected during graceful shutdown
        }
    }
}

Common follow-ups: How do you configure the ShutdownTimeout grace period?;What happens if ExecuteAsync ignores the CancellationToken entirely?

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 BackgroundServiceExceptionBehavior and how does it control host-crashing behavior?;How do you get alerted when a background service has unexpectedly stopped?

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 compare to using an external message queue like RabbitMQ or Azure Service Bus?

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 exceeds the interval?;What happens to a PeriodicTimer when it's disposed mid-wait?

protected override async Task ExecuteAsync(CancellationToken stoppingToken) {
    var schedule = CronExpression.Parse("0 2 * * *");  // 2 AM daily
    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 Hangfire or Quartz.NET instead of hand-rolling scheduling?;How do you handle a missed scheduled run if the application was down at the scheduled time?

builder.Services.AddHostedService<DatabaseMigrationService>();  // StartAsync runs first, must complete
builder.Services.AddHostedService<QueueProcessor>();             // then this one starts
builder.Services.AddHostedService<CacheWarmupService>();         // then this one
// After startup, all three ExecuteAsync loops run concurrently

Common follow-ups: What happens if one service's StartAsync throws an exception during startup?;How would you make services start concurrently instead of sequentially?

public class QueueProcessorHealthCheck : IHealthCheck {
    public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken ct) {
        var elapsed = DateTime.UtcNow - QueueProcessor.LastSuccessfulRun;
        return Task.FromResult(elapsed < TimeSpan.FromMinutes(5)
            ? HealthCheckResult.Healthy()
            : HealthCheckResult.Unhealthy("Queue processor stalled"));
    }
}

builder.Services.AddHealthChecks().AddCheck<QueueProcessorHealthCheck>("queue-processor");

Common follow-ups: How do you distinguish liveness from readiness for a background-service-heavy application?;What's the risk of a health check that restarts too aggressively?

// Direct IHostedService: no continuous loop needed
public class MetricsRegistrationService : IHostedService {
    public Task StartAsync(CancellationToken ct) {
        MetricsRegistry.Register("my-service");
        return Task.CompletedTask;
    }
    public Task StopAsync(CancellationToken ct) {
        MetricsRegistry.Unregister("my-service");
        return Task.CompletedTask;
    }
}

Common follow-ups: Why does BackgroundService exist if IHostedService already covers this case?;Can a single class implement both patterns for different concerns?