What are the risks of fire-and-forget tasks in .NET, and how would you run background work safely in ASP.NET Core?

1. Why the request scope is gone

request starts -> scope created (DbContext, IEmailSender, ...)
handler: _ = Task.Run(() => sender.SendAsync(user))   // captures scoped services
handler returns 200
response completes -> scope.DisposeAsync() -> DbContext disposed
background task (100 ms later) -> DbContext.Query(...) -> ObjectDisposedException
                                  nobody awaits -> unobserved -> silently lost

2. A complete worker with retries and drain

public sealed class EmailWorker(
    Channel<WelcomeEmail> queue,
    IServiceScopeFactory scopes,
    ILogger<EmailWorker> log) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await foreach (var item in queue.Reader.ReadAllAsync(stoppingToken))
            await ProcessWithRetryAsync(item, stoppingToken);
    }

    private async Task ProcessWithRetryAsync(WelcomeEmail item, CancellationToken ct)
    {
        for (int attempt = 1; ; attempt++)
        {
            try
            {
                await using var scope = scopes.CreateAsyncScope();
                var sender = scope.ServiceProvider.GetRequiredService<IEmailSender>();
                await sender.SendAsync(item.UserId, ct);
                return;
            }
            catch (Exception ex) when (ex is not OperationCanceledException && attempt < 3)
            {
                log.LogWarning(ex, "Attempt {Attempt} failed for {UserId}", attempt, item.UserId);
                await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)), ct);
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                log.LogError(ex, "Giving up on welcome email for {UserId}", item.UserId);
                return;   // or write to a dead-letter store
            }
        }
    }

    public override async Task StopAsync(CancellationToken cancellationToken)
    {
        queue.Writer.TryComplete();
        await base.StopAsync(cancellationToken);
        log.LogInformation("Email worker stopped with {Remaining} items unprocessed", queue.Reader.Count);
    }
}

3. Bounded channel options

For HTTP requests I prefer TryWrite + 503/429 over making requests wait indefinitely.

4. Transactional outbox sketch

await using var tx = await db.Database.BeginTransactionAsync(ct);
db.Users.Add(user);
db.Outbox.Add(new OutboxMessage("WelcomeEmail", JsonSerializer.Serialize(new { user.Id })));
await db.SaveChangesAsync(ct);
await tx.CommitAsync(ct);
// A separate worker polls Outbox, publishes, marks rows as sent. Consumers dedupe by message id.

Both the user and the intent to email are committed together: no lost emails, at the cost of possible duplicates (handled by idempotency).

5. A logged best-effort wrapper

public static class Background
{
    public static void FireAndForget(Func<Task> work, ILogger log, string name)
    {
        _ = RunAsync();
        async Task RunAsync()
        {
            try { await work().ConfigureAwait(false); }
            catch (Exception ex) { log.LogWarning(ex, "Best-effort task {Name} failed", name); }
        }
    }
}

Only for work that genuinely doesn't matter if lost, and that doesn't use scoped services.

6. Context and tracing

The background task inherits the request's ExecutionContext, so Activity.Current is the request span. If the work outlives the request, spans end after their parent and traces look broken. In a worker, start a new activity linked to the request's trace context (pass the trace id in the message).

7. Version notes

8. Try it yourself

1. Reproduce the bug: minimal API using a scoped DbContext inside _ = Task.Run(async () => { await Task.Delay(500); ... }), with logging added to see the exception.
2. Replace it with the code example's channel + worker and confirm no errors.
3. Set channel capacity to 10, flood the endpoint with bombardier, and compare Wait vs TryWrite + 503.
4. Press Ctrl+C with 500 items queued and log how many were processed before shutdown.
5. Implement a simple outbox table and publisher; kill the process mid-run and verify nothing is lost.
6. Look at the trace in Aspire/Jaeger for fire-and-forget vs worker-with-new-activity.

using System.Threading.Channels;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSingleton(Channel.CreateBounded<WelcomeEmail>(
    new BoundedChannelOptions(1_000) { FullMode = BoundedChannelFullMode.Wait }));
builder.Services.AddScoped<IEmailSender, ConsoleEmailSender>();
builder.Services.AddHostedService<EmailWorker>();
var app = builder.Build();

app.MapPost("/users/{id:int}", async (int id, Channel<WelcomeEmail> queue, CancellationToken ct) =>
{
    // Queue a small message with ids only; never capture HttpContext or scoped services.
    await queue.Writer.WriteAsync(new WelcomeEmail(id), ct);
    return Results.Accepted();
});

app.Run();

public sealed record WelcomeEmail(int UserId);

public interface IEmailSender { Task SendAsync(int userId, CancellationToken ct); }

public sealed class ConsoleEmailSender : IEmailSender
{
    public Task SendAsync(int userId, CancellationToken ct)
    {
        Console.WriteLine($"Welcome email to user {userId}");
        return Task.CompletedTask;
    }
}

public sealed class EmailWorker(
    Channel<WelcomeEmail> queue,
    IServiceScopeFactory scopes,
    ILogger<EmailWorker> log) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await foreach (var item in queue.Reader.ReadAllAsync(stoppingToken))
        {
            try
            {
                await using var scope = scopes.CreateAsyncScope();
                var sender = scope.ServiceProvider.GetRequiredService<IEmailSender>();
                await sender.SendAsync(item.UserId, stoppingToken);
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                log.LogError(ex, "Welcome email failed for {UserId}", item.UserId);
            }
        }
    }
}