基于AsyncLocal封装的FreeSql异步事务，不知道这样做有没有问题？

[coolqingcheng]

思路来自于IFreeSql 事务另类玩法

public interface IFreeSql2 : IFreeSql
{
    void BeginTran();

    void Roolback();

    void CommitTran();
}


public class FreeSql2 : IFreeSql2
{
    private readonly AsyncLocal<DbTransaction> _transaction = new();
    readonly IFreeSql _originalFsql;
    int _transactionCount;

    FreeSql.Internal.ObjectPool.Object<DbConnection> _connection;
    public FreeSql2(IFreeSql freesql)
    {
        _originalFsql = freesql;
    }
    public IAdo Ado => _originalFsql.Ado;

    public IAop Aop => _originalFsql.Aop;

    public ICodeFirst CodeFirst => _originalFsql.CodeFirst;

    public IDbFirst DbFirst => _originalFsql.DbFirst;

    public GlobalFilter GlobalFilter => _originalFsql.GlobalFilter;



    public IDelete<T1> Delete<T1>() where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Delete<T1>();
        }
        return _originalFsql.Delete<T1>().WithTransaction(_transaction.Value);
    }

    public IDelete<T1> Delete<T1>(object dywhere) where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Delete<T1>(dywhere);
        }
        return _originalFsql.Delete<T1>(dywhere).WithTransaction(_transaction.Value);
    }


    public IInsert<T1> Insert<T1>() where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Insert<T1>();
        }
        return _originalFsql.Insert<T1>().WithTransaction(_transaction.Value);
    }

    public IInsert<T1> Insert<T1>(T1 source) where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Insert<T1>(source);
        }
        return _originalFsql.Insert<T1>(source).WithTransaction(_transaction.Value);
    }

    public IInsert<T1> Insert<T1>(T1[] source) where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Insert<T1>(source);
        }
        return _originalFsql.Insert<T1>(source).WithTransaction(_transaction.Value);
    }

    public IInsert<T1> Insert<T1>(List<T1> source) where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Insert<T1>(source);
        }
        return _originalFsql.Insert<T1>(source).WithTransaction(_transaction.Value);
    }

    public IInsert<T1> Insert<T1>(IEnumerable<T1> source) where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Insert<T1>(source);
        }
        return _originalFsql.Insert<T1>(source).WithTransaction(_transaction.Value);
    }

    public IInsertOrUpdate<T1> InsertOrUpdate<T1>() where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.InsertOrUpdate<T1>();
        }
        return _originalFsql.InsertOrUpdate<T1>().WithTransaction(_transaction.Value);
    }

    public ISelect<T1> Select<T1>() where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Select<T1>();
        }
        return _originalFsql.Select<T1>().WithTransaction(_transaction.Value);
    }

    public ISelect<T1> Select<T1>(object dywhere) where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Select<T1>(dywhere);
        }
        return _originalFsql.Select<T1>(dywhere).WithTransaction(_transaction.Value);
    }

    public IUpdate<T1> Update<T1>() where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Update<T1>();
        }
        return _originalFsql.Update<T1>().WithTransaction(_transaction.Value);
    }

    public IUpdate<T1> Update<T1>(object dywhere) where T1 : class
    {
        if (_transaction.Value == null)
        {
            return _originalFsql.Update<T1>(dywhere);
        }
        return _originalFsql.Update<T1>(dywhere).WithTransaction(_transaction.Value);
    }

    public void Dispose() => TransactionCommitPriv(true);
    public void Transaction(Action handler) => TransactionPriv(null, handler);
    public void Transaction(IsolationLevel isolationLevel, Action handler) => TransactionPriv(isolationLevel, handler);
    void TransactionPriv(IsolationLevel? isolationLevel, Action? handler)
    {
        if (_transaction.Value != null)
        {
            _transactionCount++;
            return; //事务已开启
        }
        try
        {
            if (_connection == null) _connection = _originalFsql.Ado.MasterPool.Get();
            _transaction.Value = isolationLevel == null ? _connection.Value.BeginTransaction() : _connection.Value.BeginTransaction(isolationLevel.Value);
            _transactionCount = 1; //
        }
        catch
        {
            TransactionCommitPriv(false);
            throw;
        }
    }
    public void BeginTran() => TransactionPriv(null, null);
    public void CommitTran() => TransactionCommitPriv(true);
    public void Roolback() => TransactionCommitPriv(false);
    void TransactionCommitPriv(bool iscommit)
    {
        if (_transaction.Value == null) return;
        _transactionCount--;
        if (_transactionCount > 0) return; //跳过嵌套的内层事务
        try
        {
            if (iscommit == false) _transaction.Value.Rollback();
            else if (_transactionCount <= 0) _transaction.Value.Commit();
        }
        finally
        {
            if (iscommit == false || _transactionCount <= 0)
            {
                _originalFsql.Ado.MasterPool.Return(_connection);
                _connection = null;
                _transaction.Value = null;
            }
        }
    }

}

依赖注入

 services.AddScoped<IFreeSql2>(srv =>
 {
     var fsql = srv.GetService<IFreeSql>();
     return new FreeSql2(fsql!);
 });

使用

 public class TestController(IFreeSql2 fsql) : Controller
 {
     [HttpGet("/test"), AllowAnonymous]
     public async Task<IActionResult> Index()
     {
         fsql.BeginTran();
         var test = await fsql.Select<TestT>().Where(a => a.Value > 10).FirstAsync();
         await fsql.Insert<TestT>(new TestT()
         {
             Value = 1
         }).ExecuteAffrowsAsync();
         if (await fsql.Select<TestT>().CountAsync() > 1)
         {
             fsql.Roolback();
         }
         else
         {
             fsql.CommitTran();
         }
         return Content("ok");
     }
 }