如何用非持续运行的IHostedService处理按需长时间任务？

一、基于队列的BackgroundService（推荐） #

不用让HostedService持续运行无用逻辑，将其改造为任务队列消费者，仅在队列存在任务时执行操作：

• 定义任务队列服务，提供任务入队、出队的异步方法
• 实现BackgroundService，在ExecuteAsync中循环监听队列，无任务时处于等待状态，有任务则立即执行
• HTTP请求触发任务时，将耗时操作（如调用外部API）加入队列，HostedService自动取出执行

示例代码 #

任务队列接口与实现

public interface IBackgroundTaskQueue
{
    ValueTask QueueBackgroundWorkItemAsync(Func<CancellationToken, Task> workItem);
    ValueTask<Func<CancellationToken, Task>> DequeueAsync(CancellationToken cancellationToken);
}

public class BackgroundTaskQueue : IBackgroundTaskQueue
{
    private readonly Channel<Func<CancellationToken, Task>> _channel;

    public BackgroundTaskQueue(int capacity)
    {
        var options = new BoundedChannelOptions(capacity)
        {
            FullMode = BoundedChannelFullMode.Wait
        };
        _channel = Channel.CreateBounded<Func<CancellationToken, Task>>(options);
    }

    public async ValueTask QueueBackgroundWorkItemAsync(Func<CancellationToken, Task> workItem)
    {
        if (workItem == null)
            throw new ArgumentNullException(nameof(workItem));
        await _channel.Writer.WriteAsync(workItem);
    }

    public async ValueTask<Func<CancellationToken, Task>> DequeueAsync(CancellationToken cancellationToken)
    {
        return await _channel.Reader.ReadAsync(cancellationToken);
    }
}

队列驱动的HostedService

public class QueuedHostedService : BackgroundService
{
    private readonly ILogger<QueuedHostedService> _logger;
    private readonly IBackgroundTaskQueue _taskQueue;

    public QueuedHostedService(IBackgroundTaskQueue taskQueue, ILogger<QueuedHostedService> logger)
    {
        _taskQueue = taskQueue;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("队列托管服务已启动");

        while (!stoppingToken.IsCancellationRequested)
        {
            var workItem = await _taskQueue.DequeueAsync(stoppingToken);
            try
            {
                await workItem(stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "执行后台任务时出错");
            }
        }

        _logger.LogInformation("队列托管服务已停止");
    }
}

服务注册与任务触发

注册服务：

services.AddSingleton<IBackgroundTaskQueue>(_ => new BackgroundTaskQueue(capacity: 100));
services.AddHostedService<QueuedHostedService>();

在Controller中触发任务：

[ApiController]
[Route("tasks")]
public class TaskController : ControllerBase
{
    private readonly IBackgroundTaskQueue _taskQueue;

    public TaskController(IBackgroundTaskQueue taskQueue)
    {
        _taskQueue = taskQueue;
    }

    [HttpPost("trigger-long-task")]
    public async Task<IActionResult> TriggerLongTask()
    {
        await _taskQueue.QueueBackgroundWorkItemAsync(async token =>
        {
            // 替换为你的耗时API调用逻辑
            await CallExternalApiAsync(token);
        });
        return Accepted("任务已提交，后台执行中");
    }
}

这种方式下，HostedService仅在有任务时工作，无任务时处于低资源等待状态，完全按需触发，符合ASP.NET Core的设计规范。

二、直接使用Task.Run（简易场景） #

如果任务无需持久化（服务重启后任务丢失可接受），可在HTTP请求中用Task.Run将任务丢到后台线程执行：

• 注意脱离请求上下文，避免依赖已回收的请求资源
• 自行实现超时与错误处理

示例：

[HttpPost("trigger-long-task")]
public IActionResult TriggerLongTask()
{
    _ = Task.Run(async () =>
    {
        using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(10));
        try
        {
            await CallExternalApiAsync(cts.Token);
        }
        catch (Exception ex)
        {
            // 记录错误日志
        }
    });
    return Accepted("任务已提交，后台执行中");
}

缺点：服务重启或应用池回收时，未完成的任务会直接终止，无容错机制。

三、第三方任务调度库（进阶场景） #

如果需要重试、任务持久化等功能，可使用Hangfire这类库（若允许使用数据库存储任务信息）：

• 支持任务持久化到SQL Server、Redis等存储介质
• 内置重试、失败处理机制
• 完全按需触发，无任务时不占用资源

示例（Hangfire基本用法）：
注册服务：

services.AddHangfire(config => config.UseSqlServerStorage("你的数据库连接串"));
services.AddHangfireServer();

触发任务：

[HttpPost("trigger-long-task")]
public IActionResult TriggerLongTask()
{
    BackgroundJob.Enqueue(() => CallExternalApiAsync());
    return Accepted("任务已提交，后台执行中");
}

注：若无法使用公共数据库存储状态，此方案不适用。

内容的提问来源于stack exchange，提问作者Jonathan Wood