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

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

生成数据库数据

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

filldb 地址: Step 1: Upload Database schema

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

1702002573903

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

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

1702002601288

image-20231208103015730

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

image-20231208103109514

1702002685527

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

image-20231208110139302

image-20231208103454494

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

MySqlConnector 的主要部件和 API 如下:

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

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;

详细连接字符串配置可以在 MySQL Connection String Options for .NET/C# - MySqlConnector 中找到。

为了让 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 命名空间中存在很多与事务相关的代码封装。读者可以自行了解:

System.Transactions Namespace | Microsoft Learn

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

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.”

image-20231208142521404

当然,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)){//...  }
}

对于嵌套事务作用域范围,读者可以从这篇文章中了解更多:Implementing an Implicit Transaction using Transaction Scope | Microsoft Learn

封装 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 的差异比较大。

文章转载自:痴者工良

原文链接:https://www.cnblogs.com/whuanle/p/17897778.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/219806.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

redis-学习笔记(Jedis 通用命令)

flushAll 清空全部的数据库数据 jedis.flushAll();set & get set 命令 get 命令 运行结果展示 exists 判断该 key 值是否存在 当 redis 中存在该键值对时, 返回 true 如果键值对不存在, 返回 false keys 获取所有的 key 值 参数是模式匹配 *代表匹配任意个字符 _代表匹配一…

WWW 指南-万维网联盟(World Wide Web)

WWW - 万维网联盟 WWW通常称为网络。 web是一个世界各地的计算机网络。 电脑在Web上使用标准语言沟通。 万维网联盟&#xff08;W3C&#xff09;制定了Web标准 什么是WWW&#xff1f; WWW 代表 World Wide Web(万维网)万维网常常被称为 网络网络是世界各地的计算机网络网络中…

windows 服务器 怎么部署python 程序

一、要在 Windows 服务器上部署 Python 程序&#xff0c;您需要遵循以下步骤&#xff1a; 安装 Python&#xff1a;首先&#xff0c;在 Windows 服务器上安装 Python。您可以从官方网站&#xff08;https://www.python.org/downloads/windows/&#xff09;下载最新的 Python 安…

小程序开发实战案例之三 | 小程序底部导航栏如何设置

小程序中最常见的功能就是底部导航栏了&#xff0c;今天就来看一下怎么设置一个好看的导航栏&#xff5e;这里我们使用的是支付宝官方小程序 IDE 做示范。 官方提供的底部导航栏 第一步&#xff1a;页面创建 一般的小程序会有四个 tab&#xff0c;我们这次也是配置四个 tab 的…

C语言结构体和位段

自定义类型&#xff1a;结构体及联合和枚举 一.结构体类型的声明1.1 结构体的概念1.2结构的声明1.3特殊的声明1.4结构体的自引用1.5可以使用typedef重命名 二.结构体变量的创建和初始化2.1结构体变量的初始化使用{}2.2初始化&#xff1a;定义变量的同时赋初值。2.3结构体嵌套及…

Java 基础学习(八)多态、接口、造型与内部类

1 多态 1.1 多态 1.1.1 多态的意义 一个类型的引用在指向不同的对象时会有不同的实现。依然借助前面案例中的 Person类、Student类和 Teacher 类举例&#xff0c;看如下的代码&#xff1a; Person p1 new Student(); Person p2 new Teacher(); p1.schedule(); p2.schedul…

BSN实名DID服务发布会在北京召开

12月12日&#xff0c;由国家信息中心、公安部第一研究所联合主办&#xff0c;中国移动通信集团有限公司、区块链服务网络&#xff08;BSN&#xff09;发展联盟、中关村安信网络身份认证产业联盟&#xff08;OIDAA&#xff09;承办的“BSN实名DID服务发布会”在北京召开&#xf…

【代码随想录算法训练营-第六天】【哈希表】242,349,202,1

242.有效的字母异位词 第一遍 思考 比较简单&#xff0c;用数组就能实现了 class Solution {public boolean isAnagram(String s, String t) {int[] checkListi new int[256];int[] checkListj new int[256];for (int i 0; i < s.length(); i) {char checkChar s.ch…

工作随记:oracle 19c客户端通过service访问PDB异常问题

文章目录 概要技术测试分析测试1&#xff1a;测试2&#xff1a;测试3&#xff1a;测试4&#xff1a; 解决方案&#xff1a;1、修改service2、修改pdb名称 总结 概要 应用端访问提示错误信息为&#xff1a;VersionHelper异常!未将对象引用设置到对象的实例&#xff01; 此问题…

【产品】Axure的基本使用(二)

文章目录 一、元件基本介绍1.1 概述1.2 元件操作1.3 热区的使用 二、表单型元件的使用2.1 文本框2.2 文本域2.3 下拉列表2.4 列表框2.5 单选按钮2.6 复选框2.7 菜单与表格元件的使用 三、实例3.1 登录2.2 个人简历 一、元件基本介绍 1.1 概述 在Axure RP中&#xff0c;元件是…

MySQL 系列:注意 ORDER 和 LIMIT 联合使用的陷阱

文章目录 前言背后的原因ORDER BY 排序列存在相同值时返回顺序是不固定的LIMIT 和 ORDER BY 联合使用时的行为ORDER BY 或 GROUP BY 和 LIMIT 联合使用优化器默认使用有序索引 如何解决其它说明个人简介 前言 不知道大家在在分页查询中有没有遇到过这个问题&#xff0c;分页查…

数据通信网络基础

数据通信网络基础&#xff08;1&#xff09; 一.前言 • 在人类社会的起源和发展过程中&#xff0c;通信就一直伴随着我们。从20世纪七、八十年代开始&#xff0c; 人类社会已进入到信息时代&#xff0c;对于生活在信息时代的我们&#xff0c;通信的必要性更是不言而喻 的。…

使用Python监控服务器在线状态

前言 在公司内网有一台服务器&#xff0c;有动态的公网IP&#xff0c;使用DDNS对外提供服务&#xff0c;但是会因为停电、服务器卡死等原因导致服务器离线。服务器离线后无法及时获知&#xff0c;因此需要实现在服务器离线的时候能够发送消息到手机上。 思路梳理 公司办理的…

使用meta的audiobox生成广播剧

在gpt中生成对话&#xff1a; 生成一段一个小男孩和一个小女孩&#xff0c;在森林中并肩走在林间小路上的谈话&#xff0c;请用英文&#xff0c;并配有林中各种声效&#xff0c; 在gpt中生成男孩的声音描述 请用英文描述一下小男孩的声音特点 在gpt中生成女孩的声音描述 请用英…

基于单片机的电梯声控系统设计(论文+源码)

1.系统设计 在目前的高楼住宅&#xff0c;商业大厦中电梯是不可或缺的&#xff0c;而传统的电梯控制器系统&#xff0c;通常需要用户用手去按下按键进行控制&#xff0c;但是这种方式在有些情况下&#xff0c;并不完善&#xff0c;比如在本次新冠疫情期间&#xff0c;由于新冠…

甲醛酒精氢气浓度检测MP503传感器模块设计原理说明

模块简介: 本模块采集MP503空气质量传感器信号,通过单片机的10位ADC对传感器信号采样,并通过气体浓度线性曲线算法计算出气体浓度,可计算出甲醛、酒精、氢气浓度值。模块以TTL串口作为数据输出接口。 2.技术指标: 产品型号 KM-MP503 检测对象 甲醛、酒精、氢气浓度 通信…

设计模式(2)--对象创建(4)--原型

1. 意图 用原型实例指定创建对象的种类&#xff0c;并且通过拷贝这些原型创建新的对象。 2. 两种角色 抽象原型(Prototype)、具体原型(Concrete Prototype) 3. 优点 3.1 对客户隐藏了具体的产品类 3.2 可以在运行时刻增加和删除产品 3.3 可以极大地减少系统所需要的类的数目 …

OpenStack网络详解

本文主要解释了OpenStack在安装完毕——创建网段与dhcp——创建虚拟机的过程中&#xff0c;系统中多出来的这一堆网卡到底分别连接哪两部分的网卡&#xff0c;以及哪些设备是虚拟出来的。 拓扑 红色代表ovs与网桥 蓝色代表命名空间或者虚机 绿色代表网卡 网络概况 openstack安…

java设计模式学习之【享元模式】

文章目录 引言享元模式简介定义与用途实现方式 使用场景优势与劣势在Java中的应用享元模式在Spring中的应用画图示例代码地址 引言 想象一下&#xff0c;您正在开发一个游戏&#xff0c;游戏中有成千上万的树木和建筑。如果每个对象都独立存储它的所有数据&#xff0c;将会占用…

(开源)2023工训大赛智能垃圾分类项目(可循环播放视频,显示垃圾分类信息,拍照识别,垃圾分类,满载报警,压缩)

省赛:由于这个比赛是两年一届&#xff0c;并未做足充分的准备&#xff0c;但是通过一定的单片机基础&#xff0c;加上速成能力&#xff0c;也就是熬夜学&#xff0c;通过疯狂的网络搜索&#xff0c;在省赛第5 入选国赛 下面来简单介绍一下我们作品&#xff1a; 主控&#xff1…