ASP.NET MVC中如何异步执行耗时存储过程，避免阻塞用户？

针对你描述的场景，核心是要实现请求响应分离，让用户操作后立即得到反馈，后台异步执行耗时的存储过程和邮件发送任务。以下是几种成熟的实现方案，按推荐优先级排序：

方案一：使用 ASP.NET Core 内置后台服务（Hosted Service）+ 任务队列 #

这是官方推荐的轻量级方案，无需额外依赖，适合大多数场景。

实现步骤： #

1. 创建后台任务队列：定义存储待执行任务的队列接口与实现

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

public class BackgroundTaskQueue : IBackgroundTaskQueue
{
    private readonly ConcurrentQueue<Func<CancellationToken, Task>> _workItems = new();
    private readonly SemaphoreSlim _signal = new(0);

    public void QueueBackgroundWorkItem(Func<CancellationToken, Task> workItem)
    {
        if (workItem == null) throw new ArgumentNullException(nameof(workItem));
        
        _workItems.Enqueue(workItem);
        _signal.Release();
    }

    public async Task<Func<CancellationToken, Task>> DequeueAsync(CancellationToken cancellationToken)
    {
        await _signal.WaitAsync(cancellationToken);
        _workItems.TryDequeue(out var workItem);
        return workItem;
    }
}

2. 创建后台服务消费者：继承BackgroundService持续消费队列任务

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

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

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("后台任务服务已启动");

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                var workItem = await _taskQueue.DequeueAsync(stoppingToken);
                await workItem(stoppingToken);
            }
            catch (OperationCanceledException)
            {
                // 服务停止时的正常取消，无需处理
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "后台任务执行失败");
            }
        }

        _logger.LogInformation("后台任务服务已停止");
    }
}

3. 注册服务到依赖注入：在Startup.cs中添加

public void ConfigureServices(IServiceCollection services)
{
    // 注册任务队列和后台服务
    services.AddSingleton<IBackgroundTaskQueue, BackgroundTaskQueue>();
    services.AddHostedService<TaskQueueHostedService>();
    
    // 其他MVC服务注册
    services.AddControllersWithViews();
}

4. 控制器中调用：将耗时任务加入队列，立即返回响应

public class HomeController : Controller
{
    private readonly IBackgroundTaskQueue _taskQueue;
    private readonly IEmailSender _emailSender; // 自定义邮件发送服务
    private readonly YourDbContext _dbContext; // 数据库上下文

    public HomeController(IBackgroundTaskQueue taskQueue, IEmailSender emailSender, YourDbContext dbContext)
    {
        _taskQueue = taskQueue;
        _emailSender = emailSender;
        _dbContext = dbContext;
    }

    [HttpPost]
    public IActionResult Send()
    {
        // 加入后台队列
        _taskQueue.QueueBackgroundWorkItem(async token =>
        {
            try
            {
                // 执行耗时存储过程
                var result = await _dbContext.ExecuteSqlRawAsync("EXEC YourLongRunningStoredProc", token);
                
                // 根据结果发送邮件
                await _emailSender.SendEmailsAsync(result, token);
            }
            catch (Exception ex)
            {
                // 记录异常日志，可添加重试逻辑
            }
        });

        // 立即返回提示
        return Json(new { message = "我们正在处理您的请求，您很快会收到邮件" });
    }
}

优点： #

• 官方原生支持，无第三方依赖
• 轻量级，适合简单后台任务场景
• 可通过队列控制并发数

缺点： #

• 任务无持久化，应用重启后未执行任务会丢失
• 缺乏任务调度、重试、可视化管理等高级功能

方案二：使用 Hangfire（推荐用于需要高可靠性的场景） #

Hangfire是专门的.NET后台任务库，提供任务持久化、重试机制、可视化控制面板等功能，非常适合这类耗时且需可靠性的任务。

实现步骤： #

1. 安装NuGet包：

Install-Package Hangfire
Install-Package Hangfire.SqlServer // 用SQL Server存储任务，也支持其他存储介质

2. 配置Hangfire：在Startup.cs中添加

public void ConfigureServices(IServiceCollection services)
{
    // 配置Hangfire存储
    services.AddHangfire(config => 
        config.UseSqlServerStorage(Configuration.GetConnectionString("YourDbConnection")));
    
    // 启动Hangfire后台服务
    services.AddHangfireServer();
    
    // 其他MVC服务注册
    services.AddControllersWithViews();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // 其他中间件配置
    
    // 启用Hangfire控制面板（可选，用于查看任务状态）
    app.UseHangfireDashboard();
}

3. 控制器中调用：

public class HomeController : Controller
{
    private readonly IEmailSender _emailSender;
    private readonly YourDbContext _dbContext;

    public HomeController(IEmailSender emailSender, YourDbContext dbContext)
    {
        _emailSender = emailSender;
        _dbContext = dbContext;
    }

    [HttpPost]
    public IActionResult Send()
    {
        // 将任务加入Hangfire后台队列
        BackgroundJob.Enqueue(() => ExecuteLongRunningTask(_emailSender, _dbContext));

        return Json(new { message = "我们正在处理您的请求，您很快会收到邮件" });
    }

    // Hangfire自动执行此方法，需保证方法可访问
    public async Task ExecuteLongRunningTask(IEmailSender emailSender, YourDbContext dbContext)
    {
        try
        {
            var result = await dbContext.ExecuteSqlRawAsync("EXEC YourLongRunningStoredProc");
            await emailSender.SendEmailsAsync(result);
        }
        catch (Exception ex)
        {
            // Hangfire默认自动重试失败任务，也可自定义重试策略
            throw;
        }
    }
}

优点： #

• 任务持久化，应用重启后任务不会丢失
• 自带重试机制、任务调度、失败告警等功能
• 提供可视化控制面板，方便查看任务状态
• 支持延迟任务、周期性任务等高级场景

缺点： #

• 需要引入第三方依赖
• 相比内置方案稍重，但对于需要可靠性的场景非常值得

方案三：数据库触发+外部服务（适合超大规模或严格隔离的场景） #

如果任务需要更高可靠性，或需与Web应用完全隔离，可采用此方案：

1. 用户请求时，将任务信息写入数据库（如创建TaskQueue表，记录任务状态、参数）
2. 开发独立的Windows服务/控制台应用，定期轮询数据库中的待执行任务
3. 外部服务取出任务，执行存储过程和邮件发送，更新任务状态

优点： #

• 完全隔离Web应用与任务执行，避免任务影响Web应用性能
• 最高可靠性，即使Web应用宕机，外部服务仍可继续执行任务

缺点： #

• 需要额外开发和维护独立服务
• 实现复杂度高，适合大型项目

关键注意事项 #

• 异常处理：无论采用哪种方案，必须记录任务执行的异常日志，必要时添加重试机制
• 任务持久化：若不能接受任务丢失，优先选择Hangfire或数据库触发方案
• 资源控制：耗时任务可能占用大量数据库连接或CPU，需控制并发数（如Hangfire配置Worker数量、内置队列设置Semaphore）
• 用户反馈：可考虑给用户提供任务查询入口（如通过订单号或邮件查询任务状态）

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