如何处理不可await的长耗时同步工时表提交方法，支持客户端并行请求？

看起来你遇到的核心问题是同步耗时操作占用了ASP.NET请求线程，导致后续客户端请求被排队阻塞。下面给你几个可行的解决方案，从最优到次优排序：

1. 优先使用eConnect的异步API（如果存在） #

首先检查eConnectMethods是否提供了异步版本的CreateEntity方法（比如CreateEntityAsync）。如果有的话，直接用async/await改造你的方法，这是最符合ASP.NET异步模型的做法，能让请求线程及时释放回线程池处理其他请求：

public async Task<bool> SaveTimesheetsAsync(string ConnectionString, List<PATimeSheetsType> Timesheets) {
    string timesheetDocument = string.Empty;
    // 这里保留你的工时表文档创建逻辑
    bool result = false;
    eConnectMethods eConnectMethods = new eConnectMethods();
    
    // 调用异步版本的CreateEntity，用await释放线程
    result = await eConnectMethods.CreateEntityAsync(ConnectionString, timesheetDocument);
    return result;
}

然后在控制器中同样使用异步处理：

[HttpPost]
public async Task<IActionResult> SubmitTimesheets([FromBody] TimesheetRequest request) {
    bool success = await _timesheetService.SaveTimesheetsAsync(request.ConnectionString, request.Timesheets);
    return Ok(new { Status = success ? "处理成功" : "处理失败" });
}

这种方式完全不会阻塞客户端，因为await会把当前请求线程还给线程池，直到异步操作完成后再继续处理响应。

2. 用后台任务队列异步处理（无eConnect异步API时） #

如果eConnect没有提供异步方法，直接在控制器里用Task.Run并等待其实并不能解决阻塞问题（因为请求还是会等Task完成）。正确的做法是把耗时操作放到独立的后台任务队列，让客户端立即收到响应，后台再慢慢处理。

步骤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：实现后台服务处理队列 #

创建一个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("工时表后台处理服务已停止");
    }
}

步骤3：注册服务 #

在Program.cs中注册队列和后台服务：

builder.Services.AddSingleton<IBackgroundTaskQueue, BackgroundTaskQueue>();
builder.Services.AddHostedService<QueuedHostedService>();

步骤4：改造你的工时表服务 #

把耗时的CreateEntity调用放到队列中：

public class TimesheetService {
    private readonly IBackgroundTaskQueue _taskQueue;
    private readonly ILogger<TimesheetService> _logger;

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

    public void QueueSaveTimesheets(string ConnectionString, List<PATimeSheetsType> Timesheets) {
        _taskQueue.QueueBackgroundWorkItem(async token => {
            try {
                string timesheetDocument = string.Empty;
                // 这里保留你的工时表文档创建逻辑
                eConnectMethods eConnectMethods = new eConnectMethods();
                bool result = eConnectMethods.CreateEntity(ConnectionString, timesheetDocument);
                
                if (result) {
                    _logger.LogInformation("工时表同步成功");
                    // 可选：把处理结果存到数据库，方便客户端查询状态
                } else {
                    _logger.LogError("工时表同步失败");
                }
            } catch (Exception ex) {
                _logger.LogError(ex, "工时表同步过程中抛出异常");
            }
        });
    }
}

步骤5：控制器立即返回响应 #

客户端请求时，直接把任务入队并返回：

[HttpPost]
public IActionResult SubmitTimesheets([FromBody] TimesheetRequest request) {
    _timesheetService.QueueSaveTimesheets(request.ConnectionString, request.Timesheets);
    return Ok(new { Message = "工时表已提交，后台正在处理，请稍后查询状态" });
}

补充：客户端状态查询 #

你可以新增一个接口让客户端查询处理状态，比如根据工时表ID查询数据库中记录的处理结果。

为什么不推荐直接用Task.Run？ #

如果在控制器里写await Task.Run(() => SaveTimesheets(...))，虽然会把工作放到线程池，但请求仍然会等待Task完成，客户端还是会处于阻塞状态。只有把任务放到独立的后台队列，请求才会立即结束，释放线程处理其他客户端请求。

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