不同函数中使用BeginTransactionAsync的事务冲突与复用问题

• 现有实现中两个方法不管上下文状态，上来就硬调用BeginTransactionAsync创建新事务，而同一个DbContext实例同一时间仅能关联一个活跃事务
• 外层Task1已经为当前上下文绑定事务后，内层OtherTask重复触发事务创建逻辑，就会直接抛出“当前上下文已存在关联事务”的错误
• 原实现压根没区分事务的所有权：每个被调用的方法都默认自己是事务的创建者，既没有识别上下文现有事务的能力，也没有约束不能越权操作不属于自己的事务，是导致冲突的核心设计缺陷

核心原则：谁创建事务，谁负责事务的提交、回滚、全生命周期管理；嵌套调用仅复用现有事务，不重复创建、不越权操作不属于自己的事务

• 增加事务范围包装器，跟踪当前方法对事务的所有权
• 封装统一的事务获取逻辑：优先检测上下文是否已有活跃事务，有就直接复用，没有才新建事务
• 所有方法的提交、回滚、释放操作都通过包装器触发，仅对自己创建的事务生效

首先添加内部的事务范围包装器：

/// <summary>
/// 事务范围包装器，跟踪当前方法对事务的所有权
/// </summary>
private sealed class TransactionScopeWrapper : IAsyncDisposable
{
    // 仅当当前方法是事务创建者时，该字段才有值
    private readonly IDbContextTransaction? _ownTransaction;
    /// <summary>
    /// 当前是否持有事务所有权（即是否为事务的实际创建者）
    /// </summary>
    public bool IsOwnedTransaction => _ownTransaction != null;

    public TransactionScopeWrapper(IDbContextTransaction? ownTransaction)
    {
        _ownTransaction = ownTransaction;
    }

    /// <summary>
    /// 提交事务：仅对自己创建的事务执行提交操作
    /// </summary>
    public async Task CommitAsync()
    {
        if (IsOwnedTransaction)
        {
            await _ownTransaction!.CommitAsync();
        }
    }

    /// <summary>
    /// 回滚事务：仅对自己创建的事务执行回滚操作
    /// </summary>
    public async Task RollbackAsync()
    {
        if (IsOwnedTransaction)
        {
            await _ownTransaction!.RollbackAsync();
        }
    }

    public async ValueTask DisposeAsync()
    {
        // 仅释放自己创建的事务，复用的事务由外层负责释放
        if (IsOwnedTransaction)
        {
            await _ownTransaction!.DisposeAsync();
        }
    }
}

然后添加统一的事务获取方法，替换原来无差别开事务的逻辑：

private async Task<TransactionScopeWrapper> GetOrCreateTransactionAsync()
{
    // 先检查当前上下文是否已经存在活跃事务
    var existingTransaction = _context.Database.CurrentTransaction;
    if (existingTransaction != null)
    {
        // 存在事务则直接进入复用模式，不持有事务所有权
        return new TransactionScopeWrapper(ownTransaction: null);
    }
    // 无现有事务时自己创建新事务，持有事务所有权
    var newTransaction = await _context.Database.BeginTransactionAsync();
    return new TransactionScopeWrapper(ownTransaction: newTransaction);
}

最后修改原有业务方法，替换原来的事务操作逻辑：

public async Task Task1()
{
    await using var transactionScope = await GetOrCreateTransactionAsync();
    try
    {
        // 原有业务逻辑
        await OtherTask();
        // 仅当持有事务所有权时才会实际执行提交
        await transactionScope.CommitAsync();
    }
    catch (Exception e)
    {
        // 异常时仅持有事务所有权的方法会执行实际回滚
        await transactionScope.RollbackAsync();
        throw new Exception(e.Message, e);
    }
}

public async Task OtherTask()
{
    await using var transactionScope = await GetOrCreateTransactionAsync();
    try
    {
        // 原有业务逻辑
        await transactionScope.CommitAsync();
    }
    catch (Exception e)
    {
        await transactionScope.RollbackAsync();
        throw new Exception(e.Message, e);
    }
}

• 方法独立执行时：上下文没有预先绑定的事务，方法会自动开启自身事务，完成提交、释放全流程，和原有独立执行的逻辑完全一致
• 被外层逻辑嵌套调用时：方法会检测到上下文已存在的外层事务，自动进入复用模式，不会重复开启新事务，也不会越权提交、回滚不属于自己的事务，所有事务操作由最外层的事务创建者统一管控，彻底避免重复开事务的冲突
• 支持任意层级的嵌套调用，只要保持统一的事务获取逻辑，就不会出现事务冲突问题

• 这套事务复用逻辑基于同一个DbContext实例实现，如果跨不同DbContext实例调用，这套逻辑不生效，跨实例的事务需要依托分布式事务或者系统级TransactionScope实现
• 不要在复用事务的嵌套方法中手动直接操作上下文的Database.CurrentTransaction，所有生命周期操作必须通过包装器走所有权校验，避免出现事务被提前提交、释放的问题
• 异常场景不需要在复用方法中做特殊处理，直接将异常向上抛出即可，最外层的事务创建者捕获异常后会统一执行回滚操作

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