使用UnitOfWork与异步编程时出现上下文操作冲突问题求助

这个错误我太熟悉了——本质就是Entity Framework的DbContext（你的CAMSDbEntities）不是线程安全的，当你在同一个上下文实例上同时启动多个异步操作（没等前一个await完成就调用下一个），就会触发这个异常。你的UnitOfWork共享了同一个_context实例，多个仓储如果同时发起异步CRUD操作，自然会踩这个坑。

下面给你几个针对性的解决方案：

1. 先排查业务代码：确保异步操作串行执行 #

先检查调用UnitOfWork的业务逻辑，是不是存在没await就并行启动多个异步操作的情况：

// ❌ 错误示例：同时启动两个异步操作，共享同一个context
var userTask = unitOfWork.UserRepository.GetAllAsync();
var orderTask = unitOfWork.OrderRepository.GetAllAsync();

var users = await userTask;
var orders = await orderTask;

哪怕最后都await了，两个任务还是会同时访问同一个DbContext，触发冲突。改成串行执行即可：

// ✅ 正确：等第一个操作完成再启动第二个
var users = await unitOfWork.UserRepository.GetAllAsync();
var orders = await unitOfWork.OrderRepository.GetAllAsync();

2. 修改UnitOfWork：添加异步锁控制并发 #

如果业务上必须保持当前的UnitOfWork共享上下文模式，可以给UnitOfWork加一个异步锁，强制所有异步操作串行处理，避免上下文冲突：

public class UnitOfWork : IUnitOfWork
{
    private readonly CAMSDbEntities _context;
    private bool _disposed;
    public Dictionary<Type, object> repositories = new Dictionary<Type, object>();
    // 异步锁：同一时间只允许一个异步操作访问context
    private readonly SemaphoreSlim _asyncLock = new SemaphoreSlim(1, 1);

    // 原有的构造函数等代码...

    // 给仓储的异步方法包装锁
    public async Task<TEntity> GetAsync<TEntity>(int id) where TEntity : class
    {
        await _asyncLock.WaitAsync();
        try
        {
            var repository = GetRepository<TEntity>();
            return await repository.GetAsync(id);
        }
        finally
        {
            _asyncLock.Release();
        }
    }

    // SaveChangesAsync也要加锁
    public async Task<int> SaveChangesAsync()
    {
        await _asyncLock.WaitAsync();
        try
        {
            return await _context.SaveChangesAsync();
        }
        finally
        {
            _asyncLock.Release();
        }
    }

    // 释放资源时别忘了释放锁
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                _asyncLock.Dispose();
                _context.Dispose();
            }
            _disposed = true;
        }
    }
}

这个方案不需要修改业务代码，但会牺牲并行性能，适合不需要高并发的场景。

3. 推荐方案：为并行操作分配独立的UnitOfWork #

EF官方推荐的DbContext使用方式是短期实例化——每个工作单元对应一个独立的DbContext。如果你的业务需要并行处理数据，最好给每个并行任务创建独立的UnitOfWork实例：

// ✅ 并行操作的正确姿势：每个任务用自己的UnitOfWork
var userTask = Task.Run(async () =>
{
    using (var uow = new UnitOfWork())
    {
        return await uow.UserRepository.GetAllAsync();
    }
});

var orderTask = Task.Run(async () =>
{
    using (var uow = new UnitOfWork())
    {
        return await uow.OrderRepository.GetAllAsync();
    }
});

var users = await userTask;
var orders = await orderTask;

这样每个UnitOfWork的上下文都是独立的，完全不会互相干扰，也符合EF的设计原则。

4. 检查仓储实现：避免同步阻塞异步方法 #

最后还要排查你的仓储代码，有没有在异步方法里用.Result或.Wait()同步阻塞的情况——这不仅会导致死锁，也可能触发上下文冲突：

// ❌ 错误示例：同步阻塞异步操作
public TEntity Get(int id)
{
    return _context.Set<TEntity>().FindAsync(id).Result;
}

改成标准的异步实现：

// ✅ 正确的异步实现
public async Task<TEntity> GetAsync(int id)
{
    return await _context.Set<TEntity>().FindAsync(id);
}

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