ASP.NET MVC中如何并行执行两方法且不阻塞主操作

看起来你遇到的核心问题是：想在HttpPost的Action里并行执行发送短信的操作，不让主流程被阻塞，而且发短信属于非关键操作——就算失败也不能影响主请求的响应。之前尝试用async/await但没达到预期，因为用了await之后主方法还是会等待短信发送完成，反而阻塞了流程。

我来帮你理清问题并给出合适的解决方案：

为什么你的async尝试没生效？ #

你的sendSMS方法里用了await Task.FromResult(0)，这其实是个伪异步操作，根本没有真正的异步逻辑（比如调用第三方SMS接口的HTTP请求）。而且就算你的方法是真异步，在Action里用await sendSMS()也会让主方法等待这个任务完成，完全达不到“并行执行、不阻塞”的效果。

正确的解决方案 #

根据短信发送的重要程度，我们分两种情况处理：

情况1：短信发送允许偶尔丢失（非强一致性要求）

如果短信发送失败或者中途被终止也没关系，我们可以直接把异步的发短信任务丢到后台执行，主流程直接返回。但要注意捕获所有异常，避免未处理异常导致应用崩溃。

首先，先把sendSMS改成真正的异步方法（假设你是调用第三方HTTP接口发送短信）：

private async Task SendSMSAsync()
{
    try
    {
        // 这里替换成你实际调用SMS服务的异步代码
        using (var httpClient = new HttpClient())
        {
            var smsContent = new StringContent("你的短信内容", Encoding.UTF8, "application/json");
            var response = await httpClient.PostAsync("https://your-sms-service.com/api/send", smsContent);
            
            // 可以记录日志，不用抛出异常影响主流程
            if (!response.IsSuccessStatusCode)
            {
                // 这里用你项目的日志组件记录失败信息
                Logger.LogError("短信发送失败，服务返回状态码：{StatusCode}", response.StatusCode);
            }
        }
    }
    catch (Exception ex)
    {
        // 捕获所有异常，避免后台任务抛出未处理异常
        Logger.LogError(ex, "短信发送过程中发生异常");
    }
}

然后在主Action里，不要用await，直接触发这个异步任务，并用ContinueWith处理可能的异常：

[HttpPost]
[ValidateAntiForgeryToken]
public JsonResult ServicesRes(FormCollection collection)
{
    // 这里是你的主业务逻辑处理
    var result = new { Success = true, Message = "操作完成" };
    ...

    // 后台执行短信发送，不等待结果
    _ = SendSMSAsync().ContinueWith(task =>
    {
        if (task.Exception != null)
        {
            Logger.LogError(task.Exception, "后台短信任务发生未捕获异常");
        }
    }, TaskContinuationOptions.OnlyOnFaulted);

    return Json(result, JsonRequestBehavior.AllowGet);
}

⚠️ 注意：这种方式有个风险——ASP.NET的应用池可能在请求结束后回收进程，导致还在执行的后台短信任务被中断。如果你的业务能接受这种小概率的丢失，这个方案足够简单。

情况2：短信发送必须保证完成（强一致性要求）

如果短信必须发送成功，那上面的简单方案就不适用了。我们需要用后台任务队列，让任务脱离请求上下文，在后台持续执行直到完成。

以.NET Core/.NET 5+为例，步骤如下：

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. 实现后台服务来处理队列任务

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("后台任务队列服务已停止");
    }
}

3. 在Startup中注册服务

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

4. 在Controller中使用队列

private readonly IBackgroundTaskQueue _backgroundTaskQueue;

// 通过构造函数注入队列
public YourController(IBackgroundTaskQueue backgroundTaskQueue)
{
    _backgroundTaskQueue = backgroundTaskQueue;
}

[HttpPost]
[ValidateAntiForgeryToken]
public JsonResult ServicesRes(FormCollection collection)
{
    // 主业务逻辑处理
    var result = new { Success = true, Message = "操作完成" };
    ...

    // 将短信任务加入后台队列
    _backgroundTaskQueue.QueueBackgroundWorkItem(async ct =>
    {
        await SendSMSAsync();
    });

    return Json(result, JsonRequestBehavior.AllowGet);
}

这种方式下，即使请求已经返回，短信任务会在后台队列中被持续执行，直到完成或者遇到不可恢复的错误，能最大程度保证任务的执行。

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