All 15 Background Tasks & Hosted Services questions
More in Background Tasks & Hosted Services
What is the difference between IHostedService and the BackgroundService convenience base class? How does IHostApplicationLifetime let a BackgroundService react to application startup and shutdown events? How would you configure a BackgroundService to fail fast and crash the host if a critical startup dependency (like a message broker) is unreachable? How does graceful shutdown work for a BackgroundService, and how should ExecuteAsync respect the CancellationToken? How would you implement a cron-like scheduled background job (e.g., 'run daily at 2 AM') without a third-party scheduling library? How do background services interact with health checks to signal their operational status to an orchestrator like Kubernetes? How would you implement retry logic with exponential backoff for a background service that calls a potentially-flaky external API? How would you implement a background task queue accepting ad-hoc work items dynamically at runtime, rather than a fixed polling loop? How do you test a BackgroundService's business logic without waiting for its actual polling interval, keeping tests fast?
Advertisement
ASP.NET Core › Background Tasks & Hosted Services

How would you implement a producer-consumer background processing pipeline using System.Threading.Channels alongside a BackgroundService?

Advanced

Answer

Channel<T> provides a high-performance, thread-safe async queue -- a producer (like an API endpoint) writes items via ChannelWriter.WriteAsync, while a BackgroundService acts as the consumer, reading items via ChannelReader.ReadAllAsync in a loop, decoupling request-handling latency from background processing time while a bounded channel provides built-in backpressure if the queue fills up.
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);
        }
    }
}
Real-world example An API endpoint accepting bulk email requests writes each email to a bounded Channel and returns immediately (202 Accepted), while a background service consumes and actually sends the emails, keeping the API responsive under heavy load.

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?

Concurrency (asyncio/threading/multiprocessing);Rate Limiting
All 15 Background Tasks & Hosted Services questions