What is the correct pattern to run background tasks in ASP.NET Core?

Use IHostedService or derive from BackgroundService to implement long-running background work in ASP.NET Core.

How do you gracefully shut down background tasks?

Implement cancellation support using the CancellationToken passed into the ExecuteAsync method.

Implementing Background Work in ASP.NET Core | FullStackPrep.Dev

💡 Concept Name

IHostedService / BackgroundService Pattern

📘 Quick Intro

ASP.NET Core supports background tasks using the `IHostedService` or `BackgroundService` interfaces. These services are started when the application launches and run in the background, independent of HTTP requests.

🧠 Analogy / Short Story

Imagine a web app as a coffee shop. The HTTP requests are customer orders. But behind the scenes, you have a dishwasher that runs continuously—quietly cleaning up, independent of customer interactions. That’s your `BackgroundService`—doing essential work behind the curtain.

🔧 Technical Explanation

🔁 IHostedService: Interface to manage background task lifecycle (start/stop).
📦 BackgroundService: Abstract base class implementing IHostedService with a `ExecuteAsync()` method.
⏲️ Runs independently of HTTP pipeline, useful for polling, message queues, or scheduled work.
🧵 Tasks run on background threads with graceful shutdown support via `CancellationToken`.
🛡️ Automatically managed by ASP.NET Core's built-in DI system.

🎯 Purpose & Use Case

✅ Queue processing (e.g., RabbitMQ, Azure Service Bus).
✅ Background file cleanup or report generation.
✅ Scheduled tasks using timers or CRON-like logic.
✅ Heartbeat monitoring or health checks.

💻 Real Code Example

Here’s a simple implementation using BackgroundService:

public class WorkerService : BackgroundService
{
    private readonly ILogger<WorkerService> _logger;

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

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Background task running at: {time}", DateTimeOffset.Now);
            await Task.Delay(5000, stoppingToken);
        }
    }
}

// In Program.cs or Startup.cs
builder.Services.AddHostedService<WorkerService>();

❓ Interview Q&A

Q1: How do you implement a background task in ASP.NET Core?
A: Use IHostedService or BackgroundService.

Q2: What’s the difference between IHostedService and BackgroundService?
A: BackgroundService is an abstract class simplifying IHostedService with an ExecuteAsync method.

Q3: Are background services tied to HTTP requests?
A: No, they run independently of HTTP pipelines.

Q4: How do you stop a background task gracefully?
A: Use the CancellationToken passed to ExecuteAsync.

Q5: Where do you register background services?
A: In `Program.cs` using `builder.Services.AddHostedService<>()`.

📝 MCQs

Q1. Which interface is used for background work in ASP.NET Core?

IDisposable
IStartupFilter
IHostedService
IWebHost

Q2. What method must you override in BackgroundService?

Run
Start
Execute
ExecuteAsync

Q3. How are background services registered?

AddTransient
AddScoped
UseMiddleware
AddHostedService<T>()

Q4. Do background services block HTTP requests?

Yes
Sometimes
No
Only in Development

Q5. What is passed to support graceful shutdown?

TaskCompletionSource
HttpContext
ILogger
CancellationToken

💡 Bonus Insight

While BackgroundService is best for continuous or polling tasks, consider using libraries like Hangfire, Quartz.NET, or Worker Services for complex scheduling or job persistence needs.

📄 PDF Download

Need a handy summary for your notes? Download this topic as a PDF!

📄 PDF Download Coming Soon

Implementing Background Work in ASP.NET Core