.NET 8 Background Tasks: Easily Schedule Jobs with Hosted Services

Want to run background tasks without bogging down your .NET 8 application? Discover the power of Hosted Services! This guide provides actionable insights and clear examples to efficiently manage scheduled tasks and background processes.

Why Use .NET 8 Hosted Services for Background Jobs?

Background jobs are crucial for tasks like sending emails, cleaning up data, and processing messages. .NET 8's Hosted Services offer a clean, dependency injection-friendly way to execute these tasks alongside your core application.

Here's why you should consider Hosted Services:

• Clean Architecture: Integrates seamlessly with your existing .NET 8 application structure.
• Dependency Injection: Leverages DI for easy access to services and configurations.
• Graceful Shutdown: Supports proper shutdown procedures to prevent data loss.
• Simplified Scheduling: Makes implementation of .NET 8 scheduled tasks easier than ever.

Understanding .NET 8 Hosted Services: Two Key Approaches

A Hosted Service is a class that runs unobtrusively in the background of your .NET 8 application. There are two primary ways to implement these services:

1. Implement IHostedService: Define StartAsync(CancellationToken) and StopAsync(CancellationToken) methods to control the service's lifecycle.
2. Derive from BackgroundService: Override the ExecuteAsync(CancellationToken) method for long-running tasks or loops that need to execute more complex .NET 8 background tasks.

Both approaches integrate seamlessly with the Generic Host (used in both minimal APIs and traditional HostBuilder), providing access to dependency injection, configuration, and graceful shutdown capabilities.

Creating a Simple .NET 8 Background Task With BackgroundService

Let's build a basic service that logs a message every 10 seconds:

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

public class TimedLoggerService : BackgroundService
{
    private readonly ILogger<TimedLoggerService> _logger;
    private readonly TimeSpan _interval = TimeSpan.FromSeconds(10);

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

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("TimedLoggerService started.");

        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("TimedLoggerService heartbeat at: {time}", DateTimeOffset.Now);
            await Task.Delay(_interval, stoppingToken);
        }

        _logger.LogInformation("TimedLoggerService stopping.");
    }
}

Register the service in your Program.cs file:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHostedService<TimedLoggerService>();
var app = builder.Build();
app.Run();

Scheduling Recurring Tasks in .NET 8

Using PeriodicTimer for Simple Intervals

.NET 8 introduces PeriodicTimer for convenient interval-based scheduling:

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    using var timer = new PeriodicTimer(TimeSpan.FromMinutes(1));
    while (await timer.WaitForNextTickAsync(stoppingToken))
    {
        // Your scheduled work here
    }
}

Cron-Style Scheduling for Complex Schedules

For more advanced scheduling using cron expressions, leverage a library like Cronos:

using Cronos;

public class CronJobService : BackgroundService
{
    private readonly CronExpression _expression = CronExpression.Parse("0 */5 * * * *"); // every 5 minutes
    private DateTimeOffset _nextRun = DateTimeOffset.MinValue;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var now = DateTimeOffset.Now;
            if (now >= _nextRun)
            {
                // Do work
                _nextRun = _expression.GetNextOccurrence(now) ?? DateTimeOffset.MaxValue;
            }
            await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
        }
    }
}

Managing One-Off .NET 8 Background Jobs

To handle fire-and-forget jobs, such as sending an email after a request, employ a Channel<T>:

public interface IBackgroundJobQueue
{
    ValueTask QueueJobAsync(Func<CancellationToken, Task> job);
    ValueTask<Func<CancellationToken, Task>> DequeueAsync(CancellationToken cancellationToken);
}

public class BackgroundJobQueue : IBackgroundJobQueue
{
    private readonly Channel<Func<CancellationToken, Task>> _queue =
        Channel.CreateUnbounded<Func<CancellationToken, Task>>();

    public async ValueTask QueueJobAsync(Func<CancellationToken, Task> job) =>
        await _queue.Writer.WriteAsync(job);

    public async ValueTask<Func<CancellationToken, Task>> DequeueAsync(CancellationToken token) =>
        await _queue.Reader.ReadAsync(token);
}

public class QueuedHostedService : BackgroundService
{
    private readonly IBackgroundJobQueue _jobQueue;
    private readonly ILogger<QueuedHostedService> _logger;

    public QueuedHostedService(IBackgroundJobQueue jobQueue, ILogger<QueuedHostedService> logger)
    {
        _jobQueue = jobQueue;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var job = await _jobQueue.DequeueAsync(stoppingToken);
            try { await job(stoppingToken); }
            catch (Exception ex) { _logger.LogError(ex, "Error executing job"); }
        }
    }
}

Register the services:

builder.Services.AddSingleton<IBackgroundJobQueue, BackgroundJobQueue>();
builder.Services.AddHostedService<QueuedHostedService>();

Real-World Use Cases for Hosted Services

• Email & Notification Sending: Offload slow SMTP calls to improve API response times.
• Data Cleanup in .NET 8: Remove stale records or temporary files on a schedule.
• Message Processing: Consume messages from queues like RabbitMQ or Azure Service Bus.
• Report Generation: Generate and store reports during off-peak hours using .NET 8 scheduled tasks.

Best Practices for Reliable .NET 8 Background Jobs

• Graceful Shutdown: Always honor the CancellationToken and clean up any resources.
• Exception Handling: Catch exceptions within your loops to prevent service crashes when handling .NET 8 background tasks.
• Logging & Metrics: Instrument your service with logs and counters (e.g., Prometheus).
• Dependency Injection: Carefully inject scoped or singleton services as appropriate.
• Backoff & Retry: Implement retry policies with exponential backoff for transient failures.
• Health Checks: Expose health check endpoints to monitor the status of your background service.

Conclusion: Harness the Power of .NET 8 Background Tasks

Hosted Services in .NET 8 offer a robust and versatile solution for managing background jobs and scheduled tasks. By adhering to the examples and best practices outlined here, you can create dependable, maintainable, and observable background processing within your .NET 8 applications.