ASP.NET Core 6.0 Web API触发长时存储过程无需等待的最优方案

针对ASP.NET Core 6.0 Web API触发10分钟级别的存储过程需求，以下是几种无需等待执行结束的实现方案：

方案一：基于SQL Server Agent作业触发 #

这是最稳定的方案，利用SQL Server自带的作业调度功能，API仅触发作业启动，无需等待存储过程执行完成。

步骤： #

1. 在SQL Server中创建作业，将执行dbo.RebuildProjectionTable存储过程作为作业步骤。
2. API中通过EF执行启动作业的SQL命令：

[HttpPost("rebuild-projection")]
public async Task<IActionResult> TriggerRebuild()
{
    using var context = _dbContext;
    // 替换为你的作业名称
    var jobName = "RebuildProjectionTableJob";
    var startJobSql = $"EXEC msdb.dbo.sp_start_job @job_name = N'{jobName}'";
    
    await context.Database.ExecuteSqlRawAsync(startJobSql);
    return Accepted("投影表重建任务已触发，将在后台执行");
}

优势： #

• 任务由SQL Server托管，即使API进程重启也不会中断执行。
• 可通过SQL Server Management Studio查看作业状态、执行日志。
• 支持配置重试、通知等扩展功能。

方案二：ASP.NET Core后台任务（BackgroundService） #

通过内置的后台任务框架，将存储过程执行逻辑放到后台线程，API请求立即返回响应。

实现： #

1. 创建后台任务类：

public class RebuildProjectionBackgroundService : BackgroundService
{
    private readonly IServiceScopeFactory _scopeFactory;
    private readonly ConcurrentQueue<Func<Task>> _taskQueue = new();
    private readonly SemaphoreSlim _signal = new(0);

    public RebuildProjectionBackgroundService(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }

    // 提供给API调用的入队方法
    public void QueueRebuildTask()
    {
        _taskQueue.Enqueue(async () =>
        {
            using var scope = _scopeFactory.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService<YourDbContext>();
            await dbContext.Database.ExecuteSqlRawAsync("EXEC dbo.RebuildProjectionTable;");
        });
        _signal.Release();
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await _signal.WaitAsync(stoppingToken);
            while (_taskQueue.TryDequeue(out var task))
            {
                await task();
            }
        }
    }
}

2. 在Program.cs注册后台服务：

builder.Services.AddHostedService<RebuildProjectionBackgroundService>();

3. API控制器调用：

[ApiController]
[Route("api/projection")]
public class ProjectionController : ControllerBase
{
    private readonly RebuildProjectionBackgroundService _backgroundService;

    public ProjectionController(RebuildProjectionBackgroundService backgroundService)
    {
        _backgroundService = backgroundService;
    }

    [HttpPost("rebuild")]
    public IActionResult TriggerRebuild()
    {
        _backgroundService.QueueRebuildTask();
        return Accepted("重建任务已加入后台执行队列");
    }
}

注意： #

• 如果API进程意外重启，未完成的后台任务会中断，适合对任务连续性要求不高的场景。
• 若需保证任务不丢失，可结合数据库存储待执行任务，后台服务启动时读取未完成任务继续执行。

方案三：消息队列解耦（企业级场景） #

通过消息队列实现API与任务执行的完全解耦，API仅发送触发消息，独立的消费者服务负责执行存储过程。

核心思路： #

1. API接收请求后，向消息队列（如SQL Server Service Broker、RabbitMQ）发送"重建投影表"消息。
2. 部署独立的消费者服务（或API内部的后台任务）监听队列，收到消息后执行存储过程。

示例（RabbitMQ简化版）： #

API发送消息：

[HttpPost("rebuild")]
public async Task<IActionResult> TriggerRebuild(IRabbitMQProducer producer)
{
    await producer.SendMessage("rebuild-projection-queue", "trigger-rebuild");
    return Accepted("重建指令已发送");
}

消费者执行任务：

public class RebuildProjectionConsumer : BackgroundService
{
    private readonly IConnection _connection;
    private readonly IModel _channel;
    private readonly IServiceScopeFactory _scopeFactory;

    public RebuildProjectionConsumer(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
        var factory = new ConnectionFactory() { HostName = "localhost" };
        _connection = factory.CreateConnection();
        _channel = _connection.CreateModel();
        _channel.QueueDeclare(queue: "rebuild-projection-queue", durable: true, exclusive: false, autoDelete: false, arguments: null);
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var consumer = new EventingBasicConsumer(_channel);
        consumer.Received += async (model, ea) =>
        {
            using var scope = _scopeFactory.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService<YourDbContext>();
            await dbContext.Database.ExecuteSqlRawAsync("EXEC dbo.RebuildProjectionTable;");
            _channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
        };
        _channel.BasicConsume(queue: "rebuild-projection-queue", autoAck: false, consumer: consumer);

        await Task.Delay(Timeout.Infinite, stoppingToken);
    }

    public override void Dispose()
    {
        _channel.Close();
        _connection.Close();
        base.Dispose();
    }
}

优势： #

• 完全解耦API与任务执行，API性能不受长时任务影响。
• 消息持久化，即使API或消费者服务重启，任务也不会丢失。
• 支持水平扩展消费者服务，应对高并发触发请求。

内容的提问来源于stack exchange，提问作者Stephen Cossgrove