C# 从代码入门 Mysql 数据库事务

2023年12月12日 2144点热度 0人点赞 0条评论

内容目录

[TOC]

在业务开发中，使用数据库事务是必不可少的。而开发中往往会使用各种 ORM 执行数据库操作，简化代码复杂度，不过，由于各种 ORM 的封装特性，开发者的使用方式也不一样，开发者想要了解 ORM 对事务做了什么处理是比较难的。因此，本文介绍数据库事务基础、Ado.net 事务、如何封装 DbContext ，读者掌握以后，可以加深对 C# 使用事务的理解，使用各种 ORM 时也会更应手。

生成数据库数据

为了演示各种事务操作，我们想要先创建 demo 数据，打开 filldb 官网，根据操作提示生成模拟数据。

filldb 地址： https://filldb.info/dummy/step1

FillDB 是一款免费工具，可快速生成大量 MySql 格式的自定义数据，用于测试软件和使用随机数据填充数据库。

1702002573903

然后按照 authors、posts 的顺序，点击 Generate ，生成数据库数据。

因为 posts 有 authors 的外键，因此生成数据的顺序是 authors、posts。

1702002601288

最后点击 Export database 导出 SQL 即可。

1702002685527

然后在数据库中导入数据。

为了连接 Mysql 数据库，这里使用 MySqlConnector 驱动，请在创建控制台项目之后，通过 nuget 引入此包。

MySqlConnector 的主要部件和 API 如下：

ADO.NET 类型	说明	异步方法	同步方法
DbConnection	连接器	OpenAsync	Open
DbConnection		BeginTransactionAsync	BeginTransaction
DbCommand	执行命令	ExecuteNonQueryAsync	ExecuteNonQuery
DbCommand		ExecuteReaderAsync	ExecuteReader
DbCommand		ExecuteScalarAsync	ExecuteScalar
DbDataReader	读取数据	NextResultAsync	NextResult
DbDataReader		ReadAsync	Read
DbTransaction	数据库事务	CommitAsync	Commit
DbTransaction		RollbackAsync	Rollback

使用同步方法可能会对托管线程池产生不利影响，如果没有正确调优，还会导致速度减慢或锁定。

Mysql 连接字符串配置示例：

const string connectionString = "Server=localhost;Port=3306;User ID=mysqltest;Password=Password123;Database=mysqldb";

或使用 MySqlConnectionStringBuilder 构建连接字符串：

var connectionBuilder = new MySqlConnectionStringBuilder()
    {
        Server = "localhost",
        Port = 3306,
        UserID = "mysqltest",
        Password = "Password123",
        Database = "mysqldb"
};
var connectionString = connectionBuilder.ConnectionString;

详细连接字符串配置可以在 https://mysqlconnector.net/connection-options/ 中找到。

为了让 MysqlConnetor 可以记录日志，需要手动配置日志程序。

完整的 nuget 包如下：

  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />
    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="8.0.0" />
    <PackageReference Include="MySqlConnector" Version="2.3.1" />
    <PackageReference Include="MySqlConnector.Logging.Microsoft.Extensions.Logging" Version="2.1.0" />
  </ItemGroup>

配置连接字符串、配置日志、创建数据库连接，完整代码示例如下：

var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
var logger = loggerFactory.CreateLogger<Program>();
var dataSourceBuilder = new MySqlDataSourceBuilder(connectionString);
dataSourceBuilder.UseLoggerFactory(loggerFactory);
await using var dataSource = dataSourceBuilder.Build();

using var connection = dataSource.CreateConnection();

经过以上配置之后，我们拥有了模拟数据库以及基础代码，下面我们来正式学习 MysqlConnetor 和数据库事务相关的知识。

Mysql 数据库事务基础

百度百科：数据库事务( transaction)是访问并可能操作各种数据项的一个数据库操作序列，这些操作要么全部执行,要么全部不执行，是一个不可分割的工作单位。事务由事务开始与事务结束之间执行的全部数据库操作组成。

数据库事务有四个特性：

原子性：原子性是指包含事务的操作要么全部执行成功，要么全部失败回滚。
一致性：一致性指事务在执行前后状态是一致的。
隔离性：一个事务所进行的修改在最终提交之前，对其他事务是不可见的。
持久性：数据一旦提交，其所作的修改将永久地保存到数据库中。

相信大家对数据库事务都不陌生，因此这里就不扯淡了，下面来讲解不同数据库事务的特征。

数据库的并发一致性问题

虽然数据库事务可以帮助我们执行数据库操作、回滚操作，但是数据库事务并发执行时，事务之间可能会相互干扰，比如脏读、幻读等现象，我们使用数据库事务时，要根据严格程度和性能之间相互平衡选择事务隔离级别。

当多个事务并发执行时，可能会出现以下问题：

脏读

事务 A 更新了数据，但还没有提交，这时事务 B 读取到事务 A 更新后的数据，然后事务 A 回滚了，事务 B 读取到的数据就成为脏数据了。

不可重复读

事务 A 对数据进行多次读取，事务 B 在事务 A 多次读取的过程中执行了更新操作并提交了，导致事务 A 多次读取到的数据并不一致。

不可重复读，特征是相同的数据，在事务 A 的不同阶段读取的数据不一样。

幻读

事务 A 在读取数据后，事务 B 向事务A读取的数据中插入了几条数据，事务 A 再次读取数据时发现多了几条数据，和之前读取的数据不一致。

幻读，前后数据量不一样。

丢失修改

事务 A 和事务 B 都对同一个数据进行修改，事务 A 先修改，事务 B 随后修改，事务 B 的修改覆盖了事务 A 的修改。

不可重复度和幻读看起来比较像，它们主要的区别是：在不可重复读中，发现数据不一致主要是数据被更新了。在幻读中，发现数据不一致主要是数据增多或者减少了。

数据库事务的隔离级别

数据库事务的隔离级别有以下四种，按隔离级别从低到高：

未提交读：一个事务在提交前，它的修改对其他事务也是可见的。
提交读：一个事务提交之后，它的修改才能被其他事务看到。
可重复读：在同一个事务中多次读取到的数据是一致的。
串行化：需要加锁实现，会强制事务串行执行。

Ado.net 中使用 System.Data.IsolationLevel 枚举表示以上几种数据库事务隔离级别：

    public enum IsolationLevel
    {
        // 未指定
        Unspecified = -1,
        // 不能覆盖来自更高度隔离的事务的挂起的更改。
        Chaos = 16,
        // 未提交读，脏读是可能的，这意味着不会发出共享锁，也不会使用独占锁。
        ReadUncommitted = 256,
        // 提交读，在读取数据时持有共享锁，以避免脏读，但是数据可以在事务结束之前更改，从而导致不可重复读取或幻像数据。
        ReadCommitted = 4096,
        // 可重复读，锁被放置在查询中使用的所有数据上，防止其他用户更新数据。防止不可重复读取，但仍然可以使用幻像行。
        RepeatableRead = 65536,
        // 串行化，将在 DataSet 上放置一个范围锁，以防止其他用户在事务完成之前更新数据集或将行插入数据集。
        Serializable = 1048576,
        // 通过存储一个应用程序可以读取而另一个应用程序正在修改相同数据的数据版本来减少阻塞。
        // 指示即使重新查询，也无法从一个事务中看到在其他事务中所做的更改。
        Snapshot = 16777216
    }

数据库的隔离级别分别可以解决数据库的脏读、不可重复读、幻读等问题。

隔离级别	脏读	不可重复读	幻读
未提交读	允许	允许	允许
提交读	不允许	允许	允许
可重复读	不允许	不允许	允许
串行化	不允许	不允许	不允许

其实也不必纠结这些问题，可以按照读写锁的情况来理解。

编程中由于多个线程并发操作两个字典：

Dictionary<string, string> a;
Dictionary<string, string> b;

第一个问题时，并发操作一个字典时，会出现线程并发异常。

所以，我们想要使用并发字典：

    ConcurrentDictionary<string, string> a;
    ConcurrentDictionary<string, string> b;

可是，当 T1 线程修改 a 完成，接着修改 b 时，线程 T2 把字典 a 修改了。这就导致了数据不一致。

使用读写锁优化，将 a、b 两个数据包在一起：

    ConcurrentDictionary<string, string> a;
    ConcurrentDictionary<string, string> b;

    private static ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    // 读
    private void Read()
    {
        try
        {
            _lock.EnterReadLock(); 
            // 读
        }
        catch { }
        finally
        {
            _lock.ExitReadLock();            // 释放读取锁
        }
    }

    // 写
    public void Write(int key, int value)
    {
        try
        {
            _lock.EnterUpgradeableReadLock();
            _lock.EnterWriteLock();
            // 写
            _lock.ExitWriteLock();
        }
        catch { }
        finally
        {
            _lock.ExitUpgradeableReadLock();
        }
    }

读写锁的原理很简单，读和写是两个冲突的操作。当没有线程 写 时，多个线程可以并发 读，此时不会有任何问题。当有一个线程 写 时，既不允许有其它线程同时在 写 ，也不允许其它线程同时在 读。也就是说，读 是可以并发的，但是写是独占的。

串行化：

当然对于数据库事务就复杂了很多。如果要按照读写锁的形式去做，那么其隔离级别相当于 串行化，整个表都被锁住，不允许事务并发执行，此时不会有 脏读、不可重复读、 幻读 这些情况。

可是，这样对于数据库来说压力是很大的，会严重拖垮数据库的性能，以及严重降低了业务程序的并发量。

当事务 A 只需要修改 id=1,2,3 的数据时，使用 串行化 级别，会锁住整个表。这样似乎有点太浪费了。

可重复读：

那么，我们只需要锁住事务 A 正在修改的那几行记录不就行了吗？那么我们把数据库事务下降一个级别，使用 可重复读。

使用 可重复读 事务级别，其被锁住的数据，依然保持安全，也就是不会被其它事务所修改。所以，不会出现 脏读、不可重复读。但是因为不是锁住整个表，因此其它事务是可以插入数据的，这就导致了会出现 幻读。当然，可重复读 出现的问题，一般来说只需要保证事务中只处理自己想要的数据即可。

可重复读 导致的 幻读 问题，比如 A 事务在 笔记本 分类下给联想笔记本型号都打 9 折优惠，可是此时 B 事务从 笔记本 分类下，增加了几个理想笔记本型号。结果，事务 A 最后一查询，把 B 事务插入的数据查询出来了。那么事务 A 查询的数据就包含了打折和未打折的数据了。

InnoDB 使用 MVCC 来实现高并发性，并实现了所有 4 个SQL标准隔离级别。InnoDB 默认为 REPEATABLE READ (可重复读)隔离级别，并且通过间隙锁(next-key locking)策略来防止在这个隔离级别上的幻读。InnoDB 不只锁定在查询中涉及的行，还会对索引结构中的间隙进行锁定，以防止幻行被插入。

提交读：

使用示例：

SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
START TRANSACTION;
UPDATE  pet SET NAME = 'A';
SELECT SLEEP(5);
SELECT * from pet;
COMMIT;

SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
START TRANSACTION;
UPDATE  pet SET NAME = 'B';
SELECT SLEEP(5);
SELECT * from pet;
COMMIT;

A 事务和 B 事务运行时，大家都对 name 做了修改，但是事务只能看到自己做出的修改，也就是说，B 事务未提交之前，A、B 都修改了数据，但是是隔离的。

A 事务修改了 name = A ，B 事务修改了 name = B ，未提交之前，A、B 事务读到的分别是 A、B，这没问题，不会干扰。

但是如果 A 先提交了事务，那么数据库的 name 值就为 A，此时 B 事务还没有提交，B 查询到的 name = A，这就是不可重复读。

提交读 只能保证事务未提交前的数据隔离。当另一个事务提交后，会导致当前事务看到的数据前后不一样。

未提交读：

这就离谱了。啥也不能保证。

对于数据库事务的理解，大家倒序建议就比较容易理解了。

`BeginTransaction()` 和 TransactionScope 的区别

在 C# Ado.net 中，主要有两种事务使用方式：

// 方式 1：
using var tran = await connection.BeginTransactionAsync();

// 方式 2：
using (TransactionScope transactionScope = new TransactionScope())
{

}

BeginTransaction() 由 IDbConnection 连接对象开启，只能作用于当前 IDbConnection 。通过调用数据库连接对象的 BeginTransaction() 方法，显式地启动了一个数据库事务，因此与同步方法异步方法不冲突。

TransactionScope 内部封装了一些 API，在TransactionScope设置的范围内，不需要显式地调用 Commit() 或 Rollback() 方法，可以跨 IDbConnection 使用，在异步方法下使用需要做额外配置。

主要区别在于 BeginTransaction() 是显式地管理事务，而 TransactionScope 则是在编程模型上提供了更为方便的自动事务管理机制。

在 System.Transactions 命名空间中存在很多与事务相关的代码封装。读者可以自行了解：

https://learn.microsoft.com/en-us/dotnet/api/system.transactions?view=net-8.0

下面来详细说明两种事务开启方式的使用区别。

`BeginTransaction()`

先说 BeginTransaction() ，其返回的是 DbTransaction 类型。

BeginTransaction() 开启事务比较简单，不过需要手动给 IDbCommand 设置事务属性。

            await connection.OpenAsync();
           // 先开启事务，再创建命令
            using var tran = await connection.BeginTransactionAsync();
            using var command = new MySqlCommand()
            {
                Connection = connection,
                // 注意这里
                Transaction = tran
            };

            try
            {
                command.CommandText = "... ...";
                await command.ExecuteNonQueryAsync();

                if(...)
                {
                    await tran.CommitAsync();
                }else
                {
                    await tran.RollbackAsync();
                }
            }
            catch (Exception ex)
            {
                await tran.RollbackAsync();
                logger.LogError(ex, "Tran error");
            }

BeginTransaction() 定义如下：

ValueTask<MySqlTransaction> BeginTransactionAsync(IsolationLevel isolationLevel, 
                                                  CancellationToken cancellationToken = default)

DbTransaction 还可以设置保存点。

            using var tran = await connection.BeginTransactionAsync();
            try
            {
                command.CommandText = "... ...";
                await command.ExecuteNonQueryAsync();

                // 保存点
                await tran.SaveAsync("stepa");

                // 释放保存点、回滚到该保存点
                if(...)
                {
                    await tran.ReleaseAsync("stepa");
                }
            }

BeginTransaction() 的使用比较简单，也不太容易出错。

可以不手动撤销

很多时候我们会在 catch{} 回滚事务，如下代码所示。

            try
            {
                ... ...
                await tran.CommitAsync();
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Tran error");
                await tran.RollbackAsync();
            }

实际上是当一个事务在 IDbConnection 中或者在此 IDbCommand 中没有主动提交时，当对象生命周期结束或主动断开连接时、被回收到连接池时，事务会自动回滚。只要没有主动提交，则之前的操作皆无效。

比如，我们执行下面的 SQL 时，posts 表会被插入一条新的数据，id 为 101。

-- 开启事务
BEGIN; -- 或者使用 START TRANSACTION;
INSERT INTO demo.posts (id, author_id, title, description, content, date)
VALUES (101, 1, '测试', '测试', '测试', '2023-12-08');
COMMIT ;

而执行以下代码时，因为没有调用 CommitAsync() 方法提交事务，因此程序结束后，插入数据库的数据并不会起效。

            using var connection = dataSource.CreateConnection();
            await connection.OpenAsync();
            using var tran = await connection.BeginTransactionAsync();
            using var command = new MySqlCommand()
            {
                Connection = connection,
                Transaction = tran
            };

            try
            {
                command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (102, 1, '测试', '测试', '测试', '2023-12-08');
                """;
                await command.ExecuteNonQueryAsync();
                // await tran.CommitAsync();
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Tran error");
            }

TransactionScope

如以下代码所示，虽然代码执行不会报错，但是其不受事务所控制，也就是说，虽然没有提交，但是数据库实实在在的插入了一条新的数据。

这是因为事务完全没有起效，因为只有在 TransactionScope 中打开的数据库连接，才会起效。

            using var connection = dataSource.CreateConnection();
            await connection.OpenAsync();

            using (TransactionScope transactionScope = new TransactionScope())
            {
                var command = connection.CreateCommand();
                try
                {
                    command.CommandText = 
                        """
                        INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                        VALUES (103, 1, '测试', '测试', '测试', '2023-12-08');
                        """;
                    await command.ExecuteNonQueryAsync();
                    //transactionScope.Complete();
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, "Tran error");
                }
            }

修正之后：

            using (TransactionScope transactionScope = new TransactionScope())
            {
                using var connection = dataSource.CreateConnection();
                await connection.OpenAsync();

                var command = connection.CreateCommand();
                try
                {
                    command.CommandText = 
                        """
                        INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                        VALUES (104, 1, '测试', '测试', '测试', '2023-12-08');
                        """;
                    await command.ExecuteNonQueryAsync();
                    //transactionScope.Complete();
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, "Tran error");
                }
            }

但是，上面的代码还是会报错。这是因为 TransactionScope 默认不支持异步方法，而该代码使用了异步，导致释放时没有使用相同的线程。

System.InvalidOperationException:“A TransactionScope must be disposed on the same thread that it was created.”

当然，TransactionScope 是支持异步的，我们只需要启用配置即可。

            using (TransactionScope transactionScope = 
            new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
            {
                using var connection = dataSource.CreateConnection();
                await connection.OpenAsync();

                var command = connection.CreateCommand();
                try
                {
                    command.CommandText = 
                        """
                        INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                        VALUES (104, 1, '测试', '测试', '测试', '2023-12-08');
                        """;
                    await command.ExecuteNonQueryAsync();
                    //transactionScope.Complete();
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, "Tran error");
                }
            }

如下代码所示，当执行代码之后，因为我们没有主动提交事务，因此，数据库中不会真的插入数据。

            using (TransactionScope transactionScope = 
                   // 使其支持异步
                   new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
            {
                using var connection = dataSource.CreateConnection();
                await connection.OpenAsync();

                var command = connection.CreateCommand();

                command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (105, 1, '测试', '测试', '测试', '2023-12-08');
                """;

                await command.ExecuteNonQueryAsync();
                //transactionScope.Complete();
            }

有了经验之后，我们发现，如果我们不调用 Complete() 方法，那么数据库中不会真的插入数据。

可是问题来了，因为是在 TransactionScope 中创建 IDbConnection 并打开连接，也就是说 TransactionScope 作用域范围大于 IDbConnection ，那么 IDbConnection 释放之后，再提交 TransactionScope ，是否可以？

            using (TransactionScope transactionScope = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
            {
                using (var connection = dataSource.CreateConnection())
                {
                    await connection.OpenAsync();
                    var command = connection.CreateCommand();
                    command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (105, 1, '测试', '测试', '测试', '2023-12-08');
                """;
                    await command.ExecuteNonQueryAsync();
                }

                transactionScope.Complete();
            }

答案是一切正常。

简化代码如下所示：

            using (TransactionScope transactionScope = ...)
            {
                using (var connection = dataSource.CreateConnection())
                {
                    await connection.OpenAsync();
                    await command.ExecuteNonQueryAsync();
                }

                transactionScope.Complete();
            }

虽然， IDbConnection 在 using 中，transactionScope.Complete() 在 using 之外，但是事务依然可以起效。如果调用 .Complete()，则事务提交。如果不调用 .Complete() 则事务不会提交。

回到本小节第一个代码示例中，事务不起效的问题。我们已经知道了是因为 IDbConnection 没有在 TransactionScope 内创建，所以导致事务不能作用。

但是，对于 ASP.NET Core 程序、Context 形式的 ORM、仓储形式的 ORM 等，由于其封装在上下文内，不太可能在开发者使用 TransactionScope 时，再手动打开 IDbConnection.Open() 。不过这些 ORM 框架大多数都做了封装，而本文末尾也介绍了几种封装方式。

总结

通过 BeginTransaction() 创建的事务，不会因为异步等出现问题，因为其是明确在一个 IDbCommand 、IDbConnection 中起效。

            using var tran = await connection.BeginTransactionAsync();
            using var command = new MySqlCommand()
            {
                Connection = connection,
                // 注意这里
                Transaction = tran
            };

所以说，通过 .BeginTransactionAsync() 使用事务，是最简单、最不容易出错的，而且其明确在哪个 IDbCommand 中使用事情，出现问题时，排除起来也相对简单。

而对于 TransactionScope 来说，笔者花费了比较多的篇幅去实验和解释，TransactionScope 是使用事务作用域实现隐式事务的，使用起来有一定难度，也容易出错。

DML 是否可以使用事务

开始的时候，笔者并没有想到这个事情，在跟同事偶然吹水时，提到了这个事情。

Mysql 的事务对删除表、创建表这些 DML 命令，其事务是无效的，起效的是表数据相关的操作，即 insert、update、delete 语句。

如下 SQL 所示，虽然回滚了事务，但是最后还是创建了视图。

-- 开启事务
use  demo;
BEGIN;
create view v_posts AS  SELECT * FROM posts;
ROLLBACK;
-- COMMIT ;

顺序多操作

先从 TransactionScope 说起，情况如下代码所示：

TransactionScope 中包含、创建了两个 IDbConnection ，并且两个 IDbConnection 都插入了数据。

也就是说使用 TransactionScope 同时管理多个 IDbConnection 。

            using (TransactionScope transactionScope = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
            {
                using (var connection = dataSource.CreateConnection())
                {
                    await connection.OpenAsync();
                    var command = connection.CreateCommand();
                    command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (108, 1, '测试', '测试', '测试', '2023-12-08');
                """;
                    await command.ExecuteNonQueryAsync();
                }

                using (var connection = dataSource.CreateConnection())
                {
                    await connection.OpenAsync();
                    var command = connection.CreateCommand();
                    command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (109, 1, '测试', '测试', '测试', '2023-12-08');
                """;
                    await command.ExecuteNonQueryAsync();
                }

                //transactionScope.Complete();
            }

这样是可以的，TransactionScope 管理在期内的所有 IDbConnection，让他们在当前的事务中保持一致。

但是 BeginTransaction() 是使用 IDbConnection.BeginTransaction() 创建的，不能跨 IDbConnection 使用。

比如，以下代码会报错：

            using var connection1 = dataSource.CreateConnection();
            using var connection2 = dataSource.CreateConnection();
            await connection1.OpenAsync();
            await connection2.OpenAsync();

            try
            {
                var tran1 = connection1.BeginTransaction();

                var command1 = connection1.CreateCommand();
                command1.Transaction = tran1;
                var command2 = connection2.CreateCommand();
                command2.Transaction = tran1;

                command1.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (108, 1, '测试', '测试', '测试', '2023-12-08');
                """;
                await command1.ExecuteNonQueryAsync();
                command2.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (108, 1, '测试', '测试', '测试', '2023-12-08');
                """;
                await command2.ExecuteNonQueryAsync();
                tran1.Commit();
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Tran error");
            }

所以，这里又有一个区别。

嵌套事务

.BeginTransaction() 不支持嵌套事务，代码如下所示：

        static async Task Main(string[] args)
        {
            using var connection = dataSource.CreateConnection();
            await connection.OpenAsync();
            var tran = connection.BeginTransaction();

            try
            {
                var command = connection.CreateCommand();
                command.Transaction = tran;
                command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (110, 1, '测试', '测试', '测试', '2023-12-08');
                """;
                await command.ExecuteNonQueryAsync();

                // 嵌套事务
                try
                {
                    await InsertAsync(connection);
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, "Tran error.");
                    await tran.RollbackAsync();
                    return;
                }

                await tran.RollbackAsync();
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Tran error");
            }
        }

        // 嵌套的子事务
        private static async Task InsertAsync(MySqlConnection connection)
        {
            var tran = connection.BeginTransaction();
            var command = connection.CreateCommand();
            command.Transaction = tran;
            command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (112, 1, '测试', '测试', '测试', '2023-12-08');
                """;
            await command.ExecuteNonQueryAsync();
            await tran.CommitAsync();
        }

当一个 IDbConnection 调用两次 .BeginTransaction() 时，代码会报错。

 System.InvalidOperationException: Transactions may not be nested.

所以，我们只能寄望于 TransactionScope。

使用 TransactionScope 做嵌套事务，可以做到灵活的逻辑定制，每个嵌套子事务都有自己的逻辑。

每个子事务只需要正常编写自己的 TransactionScope 即可，即使子事务的 TransactionScope 已提交，如果最外层的 TransactionScope 事务没有提交，则所有的事务都不会提交。

如下代码所示：

    static async Task Main(string[] args)
    {
        using var connection = dataSource.CreateConnection();
        using (TransactionScope transactionScope = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
        {
            await connection.OpenAsync();
            var command = connection.CreateCommand();
            command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (110, 1, '测试', '测试', '测试', '2023-12-08');
                """;
            await command.ExecuteNonQueryAsync();

            // 嵌套事务
            try
            {
                await InsertAsync(connection);
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Tran error.");
                return;
            }
            // transactionScope.Complete();
        }
    }

    // 嵌套的子事务
    private static async Task InsertAsync(MySqlConnection connection)
    {
        using (TransactionScope transactionScope = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
        {
            var command = connection.CreateCommand();
            command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (112, 1, '测试', '测试', '测试', '2023-12-08');
                """;
            await command.ExecuteNonQueryAsync();
            transactionScope.Complete();
        }
    }

虽然 InsertAsync() 中的事务已经提交，但是由于其受到外层 TransactionScope 事务的影响，因此当外层事务不提交时，子事务也不会提交。

当然，即使不是同一个 IDbConnection 也是可以的。

    static async Task Main(string[] args)
    {
        using var connection = dataSource.CreateConnection();
        using (TransactionScope transactionScope = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
        {
            await connection.OpenAsync();
            var command = connection.CreateCommand();
            command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (110, 1, '测试', '测试', '测试', '2023-12-08');
                """;
            await command.ExecuteNonQueryAsync();

            // 嵌套事务
            try
            {
                await InsertAsync();
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Tran error.");
                return;
            }
            // transactionScope.Complete();
        }
    }

    // 嵌套的子事务
    private static async Task InsertAsync()
    {
        using var connection = dataSource.CreateConnection();
        using (TransactionScope transactionScope = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
        {
            await connection.OpenAsync();
            var command = connection.CreateCommand();
            command.CommandText = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (112, 1, '测试', '测试', '测试', '2023-12-08');
                """;
            await command.ExecuteNonQueryAsync();
            transactionScope.Complete();
        }
    }

所以，每个方法的代码，只需要关注自己的逻辑即可。对于模块分离、职责分离的代码很有用。

事务范围

前面我们提到了 TransactionScope 的嵌套事务。

TransactionScope 对于嵌套事务的处理，有一个 TransactionScopeOption 枚举配置。

    public enum TransactionScopeOption
    {
        // 该范围需要一个事务。 如果已经存在环境事务，则使用该环境事务。 否则，在进入范围之前创建新的事务。 这是默认值。
        Required = 0,

        // 总是为该范围创建新事务。
        RequiresNew = 1,

        // 如果使用 Suppress 实例化范围，则无论是否存在环境事务，该范围都不会参与事务。使用此值实例化的范围始终将 null 作为其环境事务。
        Suppress = 2
    }

使用示例：

using(TransactionScope scope1 = new TransactionScope())
{
    // 默认支持嵌套
    using(TransactionScope scope2 = new TransactionScope(TransactionScopeOption.Required))
    {
        //...
    }

    // 不受 scope1 的影响
    using(TransactionScope scope3 = new TransactionScope(TransactionScopeOption.RequiresNew))
    {
        //...  
    }

    // 如果使用 Suppress 实例化范围，则无论是否存在环境事务，该范围都不会参与事务。
    using(TransactionScope scope4 = new TransactionScope(TransactionScopeOption.Suppress))
    {
        //...  
    }
}

对于嵌套事务作用域范围，读者可以从这篇文章中了解更多：https://learn.microsoft.com/en-us/previous-versions/ms172152(v=vs.90)?redirectedfrom=MSDN#Y1642

封装 DbContext

前面提到过，IDbConnection 需要在 TransactionScope 中打开连接，TransactionScope 才能管控其连接的事务。

不过，有一些数据库驱动已经支持了 TransactionScope ，即使不在其内打开链接也可以。比如 EFCore 框架，EFCore 自动管理 IDbConnection 的生命周期，因此我们往往不会手动管理连接，因此事务事务时，我们不太可能这样做：

MyContext _context;

using (TransactionScope transactionScope = ...)
{
    _context.Connection.Open()
}

在使用数据库事务之前，往往连接早就已经打开了。

MyContext _context;
_context.SelectAsync()....
_context.User.SectAsync()....
using (TransactionScope transactionScope = ...)
{
}

所以，我们需要封装一个上下文类型，能够在连接打开后，自动使用上下文的事务。

TransactionScope

封装一个数据库上下文，执行命令时，如果发现其在事务范围内，则主动使用上下文事务。

    public class DbContext
    {
        private readonly DbConnection _connection;

        public DbContext(DbConnection connection)
        {
            _connection = connection;
        }

        public async Task ExecuteAsync(string sql)
        {
            var command = _connection.CreateCommand();
            // 获取当前事务
            var tran = Transaction.Current;
            if (tran != null)
            {
                // 注意这里。
                _connection.EnlistTransaction(tran);
            }

            command.CommandText = sql;

            await command.ExecuteNonQueryAsync();
        }
    }

使用示例：

        using var connection = dataSource.CreateConnection();
// 在之外打开
        await connection.OpenAsync();
        var context = new DbContext(connection);

        using (TransactionScope transactionScope = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
        {
            var sql = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (111, 1, '测试', '测试', '测试', '2023-12-08');
                """;

            await context.ExecuteAsync(sql);
        }

`BeginTransaction()`

使用上下文的形式封装 BeginTransaction() 开启的事务比较简单，只需要手动维护 DbTransaction 即可。


    public class DbContext
    {
        private readonly DbConnection _connection;
        private DbTransaction? _tran;
        public DbContext(MySqlConnection connection)
        {
            _connection = connection;
        }

        public async Task OpenTran()
        {
            if (_tran != null) throw new Exception("请勿重复开启事务");
            _tran = await _connection.BeginTransactionAsync();
        }

        public async Task ExecuteAsync(string sql)
        {
            var command = _connection.CreateCommand();
            command.CommandText = sql;

            if (_tran != null)
            {
                command.Transaction = _tran;
            }
            await command.ExecuteNonQueryAsync();
        }

        public async Task EndTran()
        {
            if (_tran == null) throw new Exception("未开启事务");
            await _tran.CommitAsync();
            _tran.Dispose();
            _tran = null;
        }
    }

使用方法：

        using var connection = dataSource.CreateConnection();
        await connection.OpenAsync();
        DbContext context = new DbContext(connection);

        await context.OpenTran();
        var sql = """
                INSERT INTO demo.posts (id, author_id, title, description, content, date) 
                VALUES (111, 1, '测试', '测试', '测试', '2023-12-08');
                """;
        await context.ExecuteAsync(sql);

当然，由于不同的 ORM 封装的数据库事务方法不一样，因此 ORM 的差异比较大。

XA 事务

在日常开发中很容易会碰到 Mysql XA 事务的报错，例如：

MySqlConnector.MySqlException (0x80004005): XA_RBDEADLOCK: Transaction branch was
rolled back: deadlock was detected\n   at
MySqlConnector.Core.ServerSession.ReceiveReplyAsync(IOBehavior ioBehavior,
CancellationToken cancellationToken)

或者超时：

XA_RBTIMEOUT: Transaction branch was rolled back: took too long\n   at
MySqlConnector.Core.ServerSession.ReceiveReplyAsync(IOBehavior ioBehavior,
CancellationToken cancellationToken) in

其实数据库的 XA 事务是一种分布式事务，直接由数据库层面支持，例如在应用中可以同时连接 Postgresql、Mysql 数据库，然后开启一个 XA 事务，即使它们是不同数据库、不同 tcp 连接，但是依然会在同一个事务中，回滚时，两个数据库的数据同时回滚，大大简化了开发者多数据库协同的工作量。

当然对于相同数据库的不同连接对象也同样起效，例如项目中同时使用了两种 ORM 框架，比如 EFCore、FreeSQL，它们都有自己的连接池、DBConnection 对象，但是平常的事务只对当前 DBConnection 有些，不能跨连接、跨线程使用，所以使用 XA 使用也是一种解决办法。

但是，XA 事务消耗的性能是比本地事务高的，因此如果并不需要使用 XA 事务，那就没必要开启。

对于 XA 事务，读者可参考：https://mariadb.com/kb/en/xa-transactions/

在 C# 中使用 XA 事务非常简单，默认情况下，使用 TransactionScope 就会自动使用 XA 事务，这也是前面示例中使用 TransactionScope 不需要关心 DBConnection、多个 DBConnection、嵌套事务等的原因。

之所以 TransactionScope 默认自动使用 XA 事务，具体原因参考： https://github.com/mysql-net/MySqlConnector/issues/919

要关闭这个特性也很简单，数据库连接字符串后面加上该参数即可：