## v0.3.11

- 增加 ISelect、IInsert、IUpdate、IDelete WithTransaction 方法，将事务对象暴露给外部； - 增加 IAdo ExecuteXxx 系列方法重载，支持事务对象的传入；
2025-04-22 18:52:50 +08:00 · 2019-03-11 17:26:27 +08:00 · 2019-03-11 17:26:27 +08:00 · 4f66c3b9eb
commit 4f66c3b9eb
parent c14dd0c169
29 changed files with 216 additions and 115 deletions
--- a/Examples/repository_01/Startup.cs
+++ b/Examples/repository_01/Startup.cs
@ -67,7 +67,7 @@ namespace repository_01 {

 			var builder = new ContainerBuilder();

-			builder.RegisterFreeRepositoryAddFilter<Song>(() => a => a.Title == DateTime.Now.ToString() + System.Threading.Thread.CurrentThread.ManagedThreadId);
+			builder.RegisterFreeRepositoryAndFilter<Song>(() => a => a.Title == DateTime.Now.ToString() + System.Threading.Thread.CurrentThread.ManagedThreadId);
 			//builder.RegisterFreeGuidRepository<Song>(a => a.Id == 1, oldname => $"{oldname}_{DateTime.Now.Year}");

 			builder.Populate(services);
--- a/FreeSql.Repository/Extenssions/AutofacExtenssions.cs
+++ b/FreeSql.Repository/Extenssions/AutofacExtenssions.cs
@ -6,10 +6,10 @@ using System.Collections.Concurrent;
 using System.Linq.Expressions;
 using System.Reflection;

-public static class FreeSqlRepositoryAutofacDependencyInjection {
+public static class FreeSqlRepositoryAutofacExtenssions {

 	public static void RegisterFreeRepository(this ContainerBuilder builder) => RegisterFreeRepositoryPrivate<bool>(builder, null, null);
-	public static void RegisterFreeRepositoryAddFilter<TEntity>(this ContainerBuilder builder, Func<Expression<Func<TEntity, bool>>> filterHandler) => RegisterFreeRepositoryPrivate<TEntity>(builder, filterHandler, null);
+	public static void RegisterFreeRepositoryAndFilter<TEntity>(this ContainerBuilder builder, Func<Expression<Func<TEntity, bool>>> filterHandler) => RegisterFreeRepositoryPrivate<TEntity>(builder, filterHandler, null);

 	static ConcurrentDictionary<Type, Delegate> _dicRegisterFreeRepositorySetFilterFunc = new ConcurrentDictionary<Type, Delegate>();
 	static ConcurrentDictionary<Type, Delegate> _dicRegisterFreeRepositorySetAsTableFunc = new ConcurrentDictionary<Type, Delegate>();
--- a/FreeSql.Repository/Extenssions/IFreeSqlExtenssions.cs
+++ b/FreeSql.Repository/Extenssions/IFreeSqlExtenssions.cs
@ -5,7 +5,7 @@ using System.Collections.Concurrent;
 using System.Text;
 using System.Linq.Expressions;

-public static class IFreeSqlExtenssions {
+public static class FreeSqlRepositoryIFreeSqlExtenssions {

 	/// <summary>
 	/// 返回默认仓库类
--- a/FreeSql.Repository/FreeSql.Repository.csproj
+++ b/FreeSql.Repository/FreeSql.Repository.csproj
@ -2,7 +2,7 @@

  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
-    <Version>0.1.14</Version>
+    <Version>0.3.11</Version>
    <Authors>YeXiangQin</Authors>
    <Description>FreeSql 通用仓库层实现，支持 MySql/SqlServer/PostgreSQL/Oracle/Sqlite，读写分离、分表分库。</Description>
    <PackageProjectUrl>https://github.com/2881099/FreeSql</PackageProjectUrl>
--- a/FreeSql/FreeSql.csproj
+++ b/FreeSql/FreeSql.csproj
@ -2,7 +2,7 @@

  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
-    <Version>0.1.14</Version>
+    <Version>0.3.11</Version>
    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
    <Authors>YeXiangQin</Authors>
    <Description>打造 .NETCore 最方便的 ORM，DbFirst 与 CodeFirst 混合使用，提供从实体同步数据库，或者从数据库生成实体代码，支持 MySql/SqlServer/PostgreSQL/Oracle/Sqlite，读写分离、分表分库。</Description>
--- a/FreeSql/Interface/Curd/IDelete.cs
+++ b/FreeSql/Interface/Curd/IDelete.cs
@ -1,10 +1,19 @@
 using System;
 using System.Collections.Generic;
+using System.Data.Common;
 using System.Linq.Expressions;
 using System.Threading.Tasks;

 namespace FreeSql {
 	public interface IDelete<T1> where T1 : class {
+
+		/// <summary>
+		/// 指定事务对象
+		/// </summary>
+		/// <param name="transaction"></param>
+		/// <returns></returns>
+		IDelete<T1> WithTransaction(DbTransaction transaction);
+
 		/// <summary>
 		/// lambda表达式条件，仅支持实体基础成员（不包含导航对象）
 		/// </summary>
--- a/FreeSql/Interface/Curd/IInsert.cs
+++ b/FreeSql/Interface/Curd/IInsert.cs
@ -1,11 +1,19 @@
 using System;
 using System.Collections.Generic;
+using System.Data.Common;
 using System.Linq.Expressions;
 using System.Threading.Tasks;

 namespace FreeSql {
 	public interface IInsert<T1> where T1 : class {

+		/// <summary>
+		/// 指定事务对象
+		/// </summary>
+		/// <param name="transaction"></param>
+		/// <returns></returns>
+		IInsert<T1> WithTransaction(DbTransaction transaction);
+
 		/// <summary>
 		/// 追加准备插入的实体
 		/// </summary>
--- a/FreeSql/Interface/Curd/ISelect/ISelect0.cs
+++ b/FreeSql/Interface/Curd/ISelect/ISelect0.cs
@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Data.Common;
 using System.Linq.Expressions;
 using System.Text;
 using System.Threading.Tasks;
@ -7,6 +8,13 @@ using System.Threading.Tasks;
 namespace FreeSql {
 	public interface ISelect0<TSelect, T1> {

+		/// <summary>
+		/// 指定事务对象
+		/// </summary>
+		/// <param name="transaction"></param>
+		/// <returns></returns>
+		TSelect WithTransaction(DbTransaction transaction);
+
 		/// <summary>
 		/// 执行SQL查询，返回 T1 实体所有字段的记录，记录不存在时返回 Count 为 0 的列表
 		/// </summary>
--- a/FreeSql/Interface/Curd/IUpdate.cs
+++ b/FreeSql/Interface/Curd/IUpdate.cs
@ -1,11 +1,19 @@
 using System;
 using System.Collections.Generic;
+using System.Data.Common;
 using System.Linq.Expressions;
 using System.Threading.Tasks;

 namespace FreeSql {
 	public interface IUpdate<T1> where T1 : class {

+		/// <summary>
+		/// 指定事务对象
+		/// </summary>
+		/// <param name="transaction"></param>
+		/// <returns></returns>
+		IUpdate<T1> WithTransaction(DbTransaction transaction);
+
 		/// <summary>
 		/// 更新数据，设置更新的实体
 		/// </summary>
--- a/FreeSql/Interface/IAdo.cs
+++ b/FreeSql/Interface/IAdo.cs
@ -61,18 +61,21 @@ namespace FreeSql {
 		/// <param name="cmdText"></param>
 		/// <param name="cmdParms"></param>
 		void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 查询，ExecuteReader(dr => {}, "select * from user where age > @age", new { age = 25 })
 		/// </summary>
 		/// <param name="cmdText"></param>
 		/// <param name="parms"></param>
 		void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null);
+		void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null);
 		/// <summary>
 		/// 查询
 		/// </summary>
 		/// <param name="cmdText"></param>
 		/// <param name="cmdParms"></param>
 		object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 查询，ExecuteArray("select * from user where age > @age", new { age = 25 })
 		/// </summary>
@ -80,12 +83,14 @@ namespace FreeSql {
 		/// <param name="parms"></param>
 		/// <returns></returns>
 		object[][] ExecuteArray(string cmdText, object parms = null);
+		object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null);
 		/// <summary>
 		/// 查询
 		/// </summary>
 		/// <param name="cmdText"></param>
 		/// <param name="cmdParms"></param>
 		DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 查询，ExecuteDataTable("select * from user where age > @age", new { age = 25 })
 		/// </summary>
@ -93,6 +98,7 @@ namespace FreeSql {
 		/// <param name="parms"></param>
 		/// <returns></returns>
 		DataTable ExecuteDataTable(string cmdText, object parms = null);
+		DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null);
 		/// <summary>
 		/// 在【主库】执行
 		/// </summary>
@ -100,6 +106,7 @@ namespace FreeSql {
 		/// <param name="cmdText"></param>
 		/// <param name="cmdParms"></param>
 		int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 在【主库】执行，ExecuteNonQuery("delete from user where age > @age", new { age = 25 })
 		/// </summary>
@ -107,6 +114,7 @@ namespace FreeSql {
 		/// <param name="parms"></param>
 		/// <returns></returns>
 		int ExecuteNonQuery(string cmdText, object parms = null);
+		int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null);
 		/// <summary>
 		/// 在【主库】执行
 		/// </summary>
@ -114,6 +122,7 @@ namespace FreeSql {
 		/// <param name="cmdText"></param>
 		/// <param name="cmdParms"></param>
 		object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 在【主库】执行，ExecuteScalar("select 1 from user where age > @age", new { age = 25 })
 		/// </summary>
@ -121,6 +130,7 @@ namespace FreeSql {
 		/// <param name="parms"></param>
 		/// <returns></returns>
 		object ExecuteScalar(string cmdText, object parms = null);
+		object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null);

 		/// <summary>
 		/// 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 })
@ -131,6 +141,7 @@ namespace FreeSql {
 		/// <param name="cmdParms"></param>
 		/// <returns></returns>
 		List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 执行SQL返回对象集合，Query&lt;User&gt;("select * from user where age > @age", new { age = 25 })
 		/// </summary>
@ -139,6 +150,7 @@ namespace FreeSql {
 		/// <param name="parms"></param>
 		/// <returns></returns>
 		List<T> Query<T>(string cmdText, object parms = null);
+		List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null);

 		#region async
 		/// <summary>
@ -149,18 +161,21 @@ namespace FreeSql {
 		/// <param name="cmdText"></param>
 		/// <param name="cmdParms"></param>
 		Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 查询，ExecuteReaderAsync(dr => {}, "select * from user where age > @age", new { age = 25 })
 		/// </summary>
 		/// <param name="cmdText"></param>
 		/// <param name="parms"></param>
 		Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
+		Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null);
 		/// <summary>
 		/// 查询
 		/// </summary>
 		/// <param name="cmdText"></param>
 		/// <param name="cmdParms"></param>
 		Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 查询，ExecuteArrayAsync("select * from user where age > @age", new { age = 25 })
 		/// </summary>
@ -168,12 +183,14 @@ namespace FreeSql {
 		/// <param name="parms"></param>
 		/// <returns></returns>
 		Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null);
+		Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null);
 		/// <summary>
 		/// 查询
 		/// </summary>
 		/// <param name="cmdText"></param>
 		/// <param name="cmdParms"></param>
 		Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 查询，ExecuteDataTableAsync("select * from user where age > @age", new { age = 25 })
 		/// </summary>
@ -181,6 +198,7 @@ namespace FreeSql {
 		/// <param name="parms"></param>
 		/// <returns></returns>
 		Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null);
+		Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null);
 		/// <summary>
 		/// 在【主库】执行
 		/// </summary>
@ -188,6 +206,7 @@ namespace FreeSql {
 		/// <param name="cmdText"></param>
 		/// <param name="cmdParms"></param>
 		Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 在【主库】执行，ExecuteNonQueryAsync("delete from user where age > @age", new { age = 25 })
 		/// </summary>
@ -195,6 +214,7 @@ namespace FreeSql {
 		/// <param name="parms"></param>
 		/// <returns></returns>
 		Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null);
+		Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null);
 		/// <summary>
 		/// 在【主库】执行
 		/// </summary>
@ -202,6 +222,7 @@ namespace FreeSql {
 		/// <param name="cmdText"></param>
 		/// <param name="cmdParms"></param>
 		Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 在【主库】执行，ExecuteScalarAsync("select 1 from user where age > @age", new { age = 25 })
 		/// </summary>
@ -209,6 +230,7 @@ namespace FreeSql {
 		/// <param name="parms"></param>
 		/// <returns></returns>
 		Task<object> ExecuteScalarAsync(string cmdText, object parms = null);
+		Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null);

 		/// <summary>
 		/// 执行SQL返回对象集合，QueryAsync&lt;User&gt;("select * from user where age > @age", new SqlParameter { ParameterName = "age", Value = 25 })
@ -219,6 +241,7 @@ namespace FreeSql {
 		/// <param name="cmdParms"></param>
 		/// <returns></returns>
 		Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
+		Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms);
 		/// <summary>
 		/// 执行SQL返回对象集合，QueryAsync&lt;User&gt;("select * from user where age > @age", new { age = 25 })
 		/// </summary>
@ -227,6 +250,7 @@ namespace FreeSql {
 		/// <param name="parms"></param>
 		/// <returns></returns>
 		Task<List<T>> QueryAsync<T>(string cmdText, object parms = null);
+		Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null);
 		#endregion
 	}
 }
--- a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs
+++ b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs
@ -58,7 +58,13 @@ namespace FreeSql.Internal.CommonProvider {
 			log.Append(e.Message);
 			_log.LogError(log.ToString());

+			if (cmd.Transaction != null) {
+				var curTran = TransactionCurrentThread;
+				if (cmd.Transaction != TransactionCurrentThread) {
+					//cmd.Transaction.Rollback();
+				} else
 					RollbackTransaction();
+			}

 			AopCommandExecuted?.Invoke(cmd, log.ToString());

@ -67,13 +73,15 @@ namespace FreeSql.Internal.CommonProvider {
 		}

 		internal static ConcurrentDictionary<Type, PropertyInfo[]> dicQueryTypeGetProperties = new ConcurrentDictionary<Type, PropertyInfo[]>();
-		public List<T> Query<T>(string cmdText, object parms = null) => Query<T>(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		public List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public List<T> Query<T>(string cmdText, object parms = null) => Query<T>(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public List<T> Query<T>(DbTransaction transaction, string cmdText, object parms = null) => Query<T>(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(null, cmdType, cmdText, cmdParms);
+		public List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var ret = new List<T>();
 			var type = typeof(T);
 			int[] indexes = null;
 			var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties());
-			ExecuteReader(dr => {
+			ExecuteReader(transaction, dr => {
 				if (indexes == null) {
 					var dic = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
 					for (var a = 0; a < dr.FieldCount; a++)
@ -84,8 +92,10 @@ namespace FreeSql.Internal.CommonProvider {
 			}, cmdType, cmdText, cmdParms);
 			return ret;
 		}
-		public void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		public void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public void ExecuteReader(Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, readerHander, cmdType, cmdText, cmdParms);
+		public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;
@ -108,7 +118,7 @@ namespace FreeSql.Internal.CommonProvider {
 			}

 			Object<DbConnection> conn = null;
-			var pc = PrepareCommand(cmdType, cmdText, cmdParms, logtxt);
+			var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt);
 			if (IsTracePerformance) logtxt.Append("PrepareCommand: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
 			Exception ex = null;
 			try {
@ -178,20 +188,24 @@ namespace FreeSql.Internal.CommonProvider {
 			LoggerException(pool, pc.cmd, ex, dt, logtxt);
 			pc.cmd.Parameters.Clear();
 		}
-		public object[][] ExecuteArray(string cmdText, object parms = null) => ExecuteArray(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		public object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public object[][] ExecuteArray(string cmdText, object parms = null) => ExecuteArray(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public object[][] ExecuteArray(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArray(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public object[][] ExecuteArray(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArray(null, cmdType, cmdText, cmdParms);
+		public object[][] ExecuteArray(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			List<object[]> ret = new List<object[]>();
-			ExecuteReader(dr => {
+			ExecuteReader(transaction, dr => {
 				object[] values = new object[dr.FieldCount];
 				dr.GetValues(values);
 				ret.Add(values);
 			}, cmdType, cmdText, cmdParms);
 			return ret.ToArray();
 		}
-		public DataTable ExecuteDataTable(string cmdText, object parms = null) => ExecuteDataTable(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		public DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public DataTable ExecuteDataTable(string cmdText, object parms = null) => ExecuteDataTable(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public DataTable ExecuteDataTable(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTable(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTable(null, cmdType, cmdText, cmdParms);
+		public DataTable ExecuteDataTable(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var ret = new DataTable();
-			ExecuteReader(dr => {
+			ExecuteReader(transaction, dr => {
 				if (ret.Columns.Count == 0)
 					for (var a = 0; a < dr.FieldCount; a++) ret.Columns.Add(dr.GetName(a));
 				object[] values = new object[ret.Columns.Count];
@ -200,13 +214,15 @@ namespace FreeSql.Internal.CommonProvider {
 			}, cmdType, cmdText, cmdParms);
 			return ret;
 		}
-		public int ExecuteNonQuery(string cmdText, object parms = null) => ExecuteNonQuery(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		public int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public int ExecuteNonQuery(string cmdText, object parms = null) => ExecuteNonQuery(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQuery(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQuery(null, cmdType, cmdText, cmdParms);
+		public int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;
 			Object<DbConnection> conn = null;
-			var pc = PrepareCommand(cmdType, cmdText, cmdParms, logtxt);
+			var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt);
 			int val = 0;
 			Exception ex = null;
 			try {
@ -225,13 +241,15 @@ namespace FreeSql.Internal.CommonProvider {
 			pc.cmd.Parameters.Clear();
 			return val;
 		}
-		public object ExecuteScalar(string cmdText, object parms = null) => ExecuteScalar(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		public object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public object ExecuteScalar(string cmdText, object parms = null) => ExecuteScalar(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalar(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalar(null, cmdType, cmdText, cmdParms);
+		public object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;
 			Object<DbConnection> conn = null;
-			var pc = PrepareCommand(cmdType, cmdText, cmdParms, logtxt);
+			var pc = PrepareCommand(transaction, cmdType, cmdText, cmdParms, logtxt);
 			object val = null;
 			Exception ex = null;
 			try {
@ -251,7 +269,7 @@ namespace FreeSql.Internal.CommonProvider {
 			return val;
 		}

-		private (DbTransaction tran, DbCommand cmd) PrepareCommand(CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
+		private (DbTransaction tran, DbCommand cmd) PrepareCommand(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
 			var dt = DateTime.Now;
 			DbCommand cmd = CreateCommand();
 			cmd.CommandType = cmdType;
@ -265,7 +283,7 @@ namespace FreeSql.Internal.CommonProvider {
 				}
 			}

-			var tran = TransactionCurrentThread;
+			var tran = transaction ?? TransactionCurrentThread;
 			if (IsTracePerformance) logtxt.Append("	PrepareCommand_part1: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms cmdParms: ").Append(cmd.Parameters.Count).Append("\r\n");

 			if (tran != null) {
--- a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs
+++ b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs
@ -9,13 +9,15 @@ using System.Threading.Tasks;

 namespace FreeSql.Internal.CommonProvider {
 	partial class AdoProvider {
-		public Task<List<T>> QueryAsync<T>(string cmdText, object parms = null) => QueryAsync<T>(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		async public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public Task<List<T>> QueryAsync<T>(string cmdText, object parms = null) => QueryAsync<T>(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task<List<T>> QueryAsync<T>(DbTransaction transaction, string cmdText, object parms = null) => QueryAsync<T>(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, cmdType, cmdText, cmdParms);
+		async public Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var ret = new List<T>();
 			var type = typeof(T);
 			int[] indexes = null;
 			var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties());
-			await ExecuteReaderAsync(dr => {
+			await ExecuteReaderAsync(transaction, dr => {
 				if (indexes == null) {
 					var dic = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);
 					for (var a = 0; a < dr.FieldCount; a++)
@ -27,8 +29,10 @@ namespace FreeSql.Internal.CommonProvider {
 			}, cmdType, cmdText, cmdParms);
 			return ret;
 		}
-		public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		async public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(null, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, readerHander, cmdType, cmdText, cmdParms);
+		async public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;
@ -51,7 +55,7 @@ namespace FreeSql.Internal.CommonProvider {
 			}

 			Object<DbConnection> conn = null;
-			var cmd = PrepareCommandAsync(cmdType, cmdText, cmdParms, logtxt);
+			var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt);
 			if (IsTracePerformance) logtxt.Append("PrepareCommandAsync: ").Append(DateTime.Now.Subtract(logtxt_dt).TotalMilliseconds).Append("ms Total: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
 			Exception ex = null;
 			try {
@ -121,20 +125,24 @@ namespace FreeSql.Internal.CommonProvider {
 			LoggerException(pool, cmd, ex, dt, logtxt);
 			cmd.Parameters.Clear();
 		}
-		public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		async public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public Task<object[][]> ExecuteArrayAsync(string cmdText, object parms = null) => ExecuteArrayAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteArrayAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task<object[][]> ExecuteArrayAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteArrayAsync(null, cmdType, cmdText, cmdParms);
+		async public Task<object[][]> ExecuteArrayAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			List<object[]> ret = new List<object[]>();
-			await ExecuteReaderAsync(async dr => {
+			await ExecuteReaderAsync(transaction, async dr => {
 				object[] values = new object[dr.FieldCount];
 				for (int a = 0; a < values.Length; a++) if (!await dr.IsDBNullAsync(a)) values[a] = await dr.GetFieldValueAsync<object>(a);
 				ret.Add(values);
 			}, cmdType, cmdText, cmdParms);
 			return ret.ToArray();
 		}
-		public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		async public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public Task<DataTable> ExecuteDataTableAsync(string cmdText, object parms = null) => ExecuteDataTableAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteDataTableAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task<DataTable> ExecuteDataTableAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteDataTableAsync(null, cmdType, cmdText, cmdParms);
+		async public Task<DataTable> ExecuteDataTableAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var ret = new DataTable();
-			await ExecuteReaderAsync(async dr => {
+			await ExecuteReaderAsync(transaction, async dr => {
 				if (ret.Columns.Count == 0)
 					for (var a = 0; a < dr.FieldCount; a++) ret.Columns.Add(dr.GetName(a));
 				object[] values = new object[ret.Columns.Count];
@ -143,13 +151,15 @@ namespace FreeSql.Internal.CommonProvider {
 			}, cmdType, cmdText, cmdParms);
 			return ret;
 		}
-		public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		async public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public Task<int> ExecuteNonQueryAsync(string cmdText, object parms = null) => ExecuteNonQueryAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, cmdType, cmdText, cmdParms);
+		async public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;
 			Object<DbConnection> conn = null;
-			var cmd = PrepareCommandAsync(cmdType, cmdText, cmdParms, logtxt);
+			var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt);
 			int val = 0;
 			Exception ex = null;
 			try {
@ -168,13 +178,15 @@ namespace FreeSql.Internal.CommonProvider {
 			cmd.Parameters.Clear();
 			return val;
 		}
-		public Task<object> ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
-		async public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+		public Task<object> ExecuteScalarAsync(string cmdText, object parms = null) => ExecuteScalarAsync(null, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
+		public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, cmdType, cmdText, cmdParms);
+		async public Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;
 			Object<DbConnection> conn = null;
-			var cmd = PrepareCommandAsync(cmdType, cmdText, cmdParms, logtxt);
+			var cmd = PrepareCommandAsync(transaction, cmdType, cmdText, cmdParms, logtxt);
 			object val = null;
 			Exception ex = null;
 			try {
@ -194,7 +206,7 @@ namespace FreeSql.Internal.CommonProvider {
 			return val;
 		}

-		private DbCommand PrepareCommandAsync(CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
+		private DbCommand PrepareCommandAsync(DbTransaction transaction, CommandType cmdType, string cmdText, DbParameter[] cmdParms, StringBuilder logtxt) {
 			DateTime dt = DateTime.Now;
 			DbCommand cmd = CreateCommand();
 			cmd.CommandType = cmdType;
@ -208,7 +220,16 @@ namespace FreeSql.Internal.CommonProvider {
 				}
 			}

-			if (IsTracePerformance) logtxt.Append("	PrepareCommand_tran==null: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms cmdParms: ").Append(cmd.Parameters.Count).Append("\r\n");
+			var tran = transaction;
+
+			if (tran != null) {
+				if (IsTracePerformance) dt = DateTime.Now;
+				cmd.Connection = tran.Connection;
+				cmd.Transaction = tran;
+				if (IsTracePerformance) logtxt.Append("	PrepareCommandAsync_tran!=null: ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms\r\n");
+			}
+
+			if (IsTracePerformance) logtxt.Append("	PrepareCommandAsync ").Append(DateTime.Now.Subtract(dt).TotalMilliseconds).Append("ms cmdParms: ").Append(cmd.Parameters.Count).Append("\r\n");

 			AopCommandExecuting?.Invoke(cmd);
 			return cmd;
--- a/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderTransaction.cs
+++ b/FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderTransaction.cs
@ -47,9 +47,6 @@ namespace FreeSql.Internal.CommonProvider {
 		}
 		public void TransactionPreRemoveCache(params string[] key) => PreRemove(key);

-		/// <summary>
-		/// 启动事务
-		/// </summary>
 		public void BeginTransaction(TimeSpan timeout) {
 			int tid = Thread.CurrentThread.ManagedThreadId;
 			Transaction2 tran = null;
@ -60,6 +57,7 @@ namespace FreeSql.Internal.CommonProvider {
 				tran = new Transaction2(conn, conn.Value.BeginTransaction(), timeout);
 			} catch(Exception ex) {
 				_log.LogError($"数据库出错（开启事务）{ex.Message} \r\n{ex.StackTrace}");
+				MasterPool.Return(conn);
 				throw ex;
 			}
 			if (_trans.ContainsKey(tid)) CommitTransaction();
@ -68,9 +66,6 @@ namespace FreeSql.Internal.CommonProvider {
 				_trans.Add(tid, tran);
 		}

-		/// <summary>
-		/// 自动提交事务
-		/// </summary>
 		private void AutoCommitTransaction() {
 			if (_trans.Count > 0) {
 				Transaction2[] trans = null;
@ -110,13 +105,7 @@ namespace FreeSql.Internal.CommonProvider {
 		private void CommitTransaction(bool isCommit) {
 			if (_trans.TryGetValue(Thread.CurrentThread.ManagedThreadId, out var tran)) CommitTransaction(isCommit, tran);
 		}
-		/// <summary>
-		/// 提交事务
-		/// </summary>
 		public void CommitTransaction() => CommitTransaction(true);
-		/// <summary>
-		/// 回滚事务
-		/// </summary>
 		public void RollbackTransaction() => CommitTransaction(false);

 		public void Dispose() {
@ -126,18 +115,9 @@ namespace FreeSql.Internal.CommonProvider {
 			foreach (Transaction2 tran in trans) CommitTransaction(false, tran);
 		}

-		/// <summary>
-		/// 开启事务（不支持异步），60秒未执行完将自动提交
-		/// </summary>
-		/// <param name="handler">事务体 () => {}</param>
 		public void Transaction(Action handler) {
 			Transaction(handler, TimeSpan.FromSeconds(60));
 		}
-		/// <summary>
-		/// 开启事务（不支持异步）
-		/// </summary>
-		/// <param name="handler">事务体 () => {}</param>
-		/// <param name="timeout">超时，未执行完将自动提交</param>
 		public void Transaction(Action handler, TimeSpan timeout) {
 			try {
 				BeginTransaction(timeout);
--- a/FreeSql/Internal/CommonProvider/DeleteProvider.cs
+++ b/FreeSql/Internal/CommonProvider/DeleteProvider.cs
@ -19,6 +19,7 @@ namespace FreeSql.Internal.CommonProvider {
 		protected StringBuilder _where = new StringBuilder();
 		protected int _whereTimes = 0;
 		protected List<DbParameter> _params = new List<DbParameter>();
+		protected DbTransaction _transaction;

 		public DeleteProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
 			_orm = orm;
@ -29,15 +30,20 @@ namespace FreeSql.Internal.CommonProvider {
 			if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
 		}

+		public IDelete<T1> WithTransaction(DbTransaction transaction) {
+			_transaction = transaction;
+			return this;
+		}
+
 		public int ExecuteAffrows() {
 			var sql = this.ToSql();
 			if (string.IsNullOrEmpty(sql)) return 0;
-			return _orm.Ado.ExecuteNonQuery(CommandType.Text, sql, _params.ToArray());
+			return _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params.ToArray());
 		}
 		async public Task<int> ExecuteAffrowsAsync() {
 			var sql = this.ToSql();
 			if (string.IsNullOrEmpty(sql)) return 0;
-			return await _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, sql, _params.ToArray());
+			return await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params.ToArray());
 		}
 		public abstract List<T1> ExecuteDeleted();
 		public abstract Task<List<T1>> ExecuteDeletedAsync();
--- a/FreeSql/Internal/CommonProvider/InsertProvider.cs
+++ b/FreeSql/Internal/CommonProvider/InsertProvider.cs
@ -19,6 +19,7 @@ namespace FreeSql.Internal.CommonProvider {
 		protected TableInfo _table;
 		protected Func<string, string> _tableRule;
 		protected DbParameter[] _params;
+		protected DbTransaction _transaction;

 		public InsertProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression) {
 			_orm = orm;
@ -28,6 +29,11 @@ namespace FreeSql.Internal.CommonProvider {
 			if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
 		}

+		public IInsert<T1> WithTransaction(DbTransaction transaction) {
+			_transaction = transaction;
+			return this;
+		}
+
 		public IInsert<T1> AppendData(T1 source) {
 			if (source != null) _source.Add(source);
 			return this;
@ -37,8 +43,8 @@ namespace FreeSql.Internal.CommonProvider {
 			return this;
 		}

-		public int ExecuteAffrows() => _orm.Ado.ExecuteNonQuery(CommandType.Text, this.ToSql(), _params);
-		public Task<int> ExecuteAffrowsAsync() => _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, this.ToSql(), _params);
+		public int ExecuteAffrows() => _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, this.ToSql(), _params);
+		public Task<int> ExecuteAffrowsAsync() => _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, this.ToSql(), _params);
 		public abstract long ExecuteIdentity();
 		public abstract Task<long> ExecuteIdentityAsync();
 		public abstract List<T1> ExecuteInserted();
--- a/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs
+++ b/FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs
@ -25,6 +25,7 @@ namespace FreeSql.Internal.CommonProvider {
 		protected IFreeSql _orm;
 		protected CommonUtils _commonUtils;
 		protected CommonExpression _commonExpression;
+		protected DbTransaction _transaction;

 		internal static void CopyData(Select0Provider<TSelect, T1> from, object to) {
 			var toType = to?.GetType();
@ -44,6 +45,7 @@ namespace FreeSql.Internal.CommonProvider {
 			//toType.GetField("_orm", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._orm);
 			//toType.GetField("_commonUtils", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonUtils);
 			//toType.GetField("_commonExpression", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._commonExpression);
+			toType.GetField("_transaction", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(to, from._transaction);
 		}

 		public Select0Provider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
@ -55,6 +57,11 @@ namespace FreeSql.Internal.CommonProvider {
 			if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
 		}

+		public TSelect WithTransaction(DbTransaction transaction) {
+			_transaction = transaction;
+			return this as TSelect;
+		}
+
 		public bool Any() {
 			this.Limit(1);
 			return this.ToList<int>("1").FirstOrDefault() == 1;
@ -152,7 +159,7 @@ namespace FreeSql.Internal.CommonProvider {
 			return _orm.Cache.Shell(_cache.key, _cache.seconds, () => {
 				List<TTuple> ret = new List<TTuple>();
 				Type type = typeof(TTuple);
-				_orm.Ado.ExecuteReader(dr => {
+				_orm.Ado.ExecuteReader(_transaction, dr => {
 					var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr);
 					ret.Add((TTuple)read.Value);
 				}, CommandType.Text, sql, _params.ToArray());
@ -166,7 +173,7 @@ namespace FreeSql.Internal.CommonProvider {
 			return _orm.Cache.ShellAsync(_cache.key, _cache.seconds, async () => {
 				List<TTuple> ret = new List<TTuple>();
 				Type type = typeof(TTuple);
-				await _orm.Ado.ExecuteReaderAsync(dr => {
+				await _orm.Ado.ExecuteReaderAsync(_transaction, dr => {
 					var read = Utils.ExecuteArrayRowReadClassOrTuple(type, null, dr);
 					ret.Add((TTuple)read.Value);
 					return Task.CompletedTask;
@ -181,7 +188,7 @@ namespace FreeSql.Internal.CommonProvider {

 			return _orm.Cache.Shell(_cache.key, _cache.seconds, () => {
 				List<T1> ret = new List<T1>();
-				_orm.Ado.ExecuteReader(dr => {
+				_orm.Ado.ExecuteReader(_transaction, dr => {
 					ret.Add(af.Read(dr));
 				}, CommandType.Text, sql, _params.ToArray());
 				return ret;
@ -194,7 +201,7 @@ namespace FreeSql.Internal.CommonProvider {

 			return await _orm.Cache.ShellAsync(_cache.key, _cache.seconds, async () => {
 				List<T1> ret = new List<T1>();
-				await _orm.Ado.ExecuteReaderAsync(dr => {
+				await _orm.Ado.ExecuteReaderAsync(_transaction, dr => {
 					ret.Add(af.Read(dr));
 					return Task.CompletedTask;
 				}, CommandType.Text, sql, _params.ToArray());
@ -220,7 +227,7 @@ namespace FreeSql.Internal.CommonProvider {
 			return _orm.Cache.Shell(_cache.key, _cache.seconds, () => {
 				List<TReturn> ret = new List<TReturn>();
 				Type type = typeof(TReturn);
-				_orm.Ado.ExecuteReader(dr => {
+				_orm.Ado.ExecuteReader(_transaction, dr => {
 					var index = -1;
 					ret.Add((TReturn)_commonExpression.ReadAnonymous(af.map, dr, ref index));
 				}, CommandType.Text, sql, _params.ToArray());
@ -234,7 +241,7 @@ namespace FreeSql.Internal.CommonProvider {
 			return await _orm.Cache.ShellAsync(_cache.key, _cache.seconds, async () => {
 				List<TReturn> ret = new List<TReturn>();
 				Type type = typeof(TReturn);
-				await _orm.Ado.ExecuteReaderAsync(dr => {
+				await _orm.Ado.ExecuteReaderAsync(_transaction, dr => {
 					var index = -1;
 					ret.Add((TReturn)_commonExpression.ReadAnonymous(af.map, dr, ref index));
 					return Task.CompletedTask;
--- a/FreeSql/Internal/CommonProvider/UpdateProvider.cs
+++ b/FreeSql/Internal/CommonProvider/UpdateProvider.cs
@ -22,6 +22,7 @@ namespace FreeSql.Internal.CommonProvider {
 		protected StringBuilder _set = new StringBuilder();
 		protected List<DbParameter> _params = new List<DbParameter>();
 		protected List<DbParameter> _paramsSource = new List<DbParameter>();
+		protected DbTransaction _transaction;

 		public UpdateProvider(IFreeSql orm, CommonUtils commonUtils, CommonExpression commonExpression, object dywhere) {
 			_orm = orm;
@ -32,15 +33,20 @@ namespace FreeSql.Internal.CommonProvider {
 			if (_orm.CodeFirst.IsAutoSyncStructure) _orm.CodeFirst.SyncStructure<T1>();
 		}

+		public IUpdate<T1> WithTransaction(DbTransaction transaction) {
+			_transaction = transaction;
+			return this;
+		}
+
 		public int ExecuteAffrows() {
 			var sql = this.ToSql();
 			if (string.IsNullOrEmpty(sql)) return 0;
-			return _orm.Ado.ExecuteNonQuery(CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
+			return _orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
 		}
 		async public Task<int> ExecuteAffrowsAsync() {
 			var sql = this.ToSql();
 			if (string.IsNullOrEmpty(sql)) return 0;
-			return await _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
+			return await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params.Concat(_paramsSource).ToArray());
 		}
 		public abstract List<T1> ExecuteUpdated();
 		public abstract Task<List<T1>> ExecuteUpdatedAsync();
--- a/FreeSql/MySql/Curd/MySqlDelete.cs
+++ b/FreeSql/MySql/Curd/MySqlDelete.cs
@ -24,7 +24,7 @@ namespace FreeSql.MySql.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params.ToArray());
+			return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
 		}
 		async public override Task<List<T1>> ExecuteDeletedAsync() {
 			var sql = this.ToSql();
@ -39,7 +39,7 @@ namespace FreeSql.MySql.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params.ToArray());
+			return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
 		}
 	}
 }
--- a/FreeSql/MySql/Curd/MySqlInsert.cs
+++ b/FreeSql/MySql/Curd/MySqlInsert.cs
@ -15,13 +15,13 @@ namespace FreeSql.MySql.Curd {
 			var sql = this.ToSql();
 			if (string.IsNullOrEmpty(sql)) return 0;

-			return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0;
+			return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0;
 		}
 		async public override Task<long> ExecuteIdentityAsync() {
 			var sql = this.ToSql();
 			if (string.IsNullOrEmpty(sql)) return 0;

-			return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0;
+			return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, "; SELECT LAST_INSERT_ID();"), _params)), out var trylng) ? trylng : 0;
 		}

 		public override List<T1> ExecuteInserted() {
@ -37,7 +37,7 @@ namespace FreeSql.MySql.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params);
+			return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
 		}
 		async public override Task<List<T1>> ExecuteInsertedAsync() {
 			var sql = this.ToSql();
@ -52,7 +52,7 @@ namespace FreeSql.MySql.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params);
+			return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
 		}
 	}
 }
--- a/FreeSql/MySql/Curd/MySqlUpdate.cs
+++ b/FreeSql/MySql/Curd/MySqlUpdate.cs
@ -27,7 +27,7 @@ namespace FreeSql.MySql.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
+			return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
 		}
 		async public override Task<List<T1>> ExecuteUpdatedAsync() {
 			var sql = this.ToSql();
@ -42,7 +42,7 @@ namespace FreeSql.MySql.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
+			return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
 		}

 		protected override void ToSqlCase(StringBuilder caseWhen, ColumnInfo[] primarys) {
--- a/FreeSql/Oracle/Curd/OracleInsert.cs
+++ b/FreeSql/Oracle/Curd/OracleInsert.cs
@ -75,13 +75,13 @@ namespace FreeSql.Oracle.Curd {
 			if (string.IsNullOrEmpty(sql)) return 0;

 			if (_identCol == null || _source.Count > 1) {
-				_orm.Ado.ExecuteNonQuery(CommandType.Text, sql, _params);
+				_orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params);
 				return 0;
 			}
 			var identColName = _commonUtils.QuoteSqlName(_identCol.Attribute.Name);
 			var identParam = _commonUtils.AppendParamter(null, $"{_identCol.CsName}99", _identCol.CsType, 0) as OracleParameter;
 			identParam.Direction = ParameterDirection.Output;
-			_orm.Ado.ExecuteNonQuery(CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray());
+			_orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray());
 			return long.TryParse(string.Concat(identParam.Value), out var trylng) ? trylng : 0;
 		}
 		async public override Task<long> ExecuteIdentityAsync() {
@ -89,13 +89,13 @@ namespace FreeSql.Oracle.Curd {
 			if (string.IsNullOrEmpty(sql)) return 0;

 			if (_identCol == null || _source.Count > 1) {
-				await _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, sql, _params);
+				await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params);
 				return 0;
 			}
 			var identColName = _commonUtils.QuoteSqlName(_identCol.Attribute.Name);
 			var identParam = _commonUtils.AppendParamter(null, $"{_identCol.CsName}99", _identCol.CsType, 0) as OracleParameter;
 			identParam.Direction = ParameterDirection.Output;
-			await _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray());
+			await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, $"{sql} RETURNING {identColName} INTO {identParam.ParameterName}", _params.Concat(new[] { identParam }).ToArray());
 			return long.TryParse(string.Concat(identParam.Value), out var trylng) ? trylng : 0;
 		}

@ -142,7 +142,7 @@ namespace FreeSql.Oracle.Curd {
 //end loop;
 //end;
 //");
-//			return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params);
+//			return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
 		}
 		public override Task<List<T1>> ExecuteInsertedAsync() {
 			throw new NotImplementedException();
--- a/FreeSql/PostgreSQL/Curd/PostgreSQLDelete.cs
+++ b/FreeSql/PostgreSQL/Curd/PostgreSQLDelete.cs
@ -24,7 +24,7 @@ namespace FreeSql.PostgreSQL.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params.ToArray());
+			return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
 		}
 		async public override Task<List<T1>> ExecuteDeletedAsync() {
 			var sql = this.ToSql();
@ -39,7 +39,7 @@ namespace FreeSql.PostgreSQL.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params.ToArray());
+			return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
 		}
 	}
 }
--- a/FreeSql/PostgreSQL/Curd/PostgreSQLInsert.cs
+++ b/FreeSql/PostgreSQL/Curd/PostgreSQLInsert.cs
@ -18,10 +18,10 @@ namespace FreeSql.PostgreSQL.Curd {

 			var identCols = _table.Columns.Where(a => a.Value.Attribute.IsIdentity == true);
 			if (identCols.Any() == false) {
-				_orm.Ado.ExecuteNonQuery(CommandType.Text, sql, _params);
+				_orm.Ado.ExecuteNonQuery(_transaction, CommandType.Text, sql, _params);
 				return 0;
 			}
-			return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0;
+			return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0;
 		}
 		async public override Task<long> ExecuteIdentityAsync() {
 			var sql = this.ToSql();
@ -29,10 +29,10 @@ namespace FreeSql.PostgreSQL.Curd {

 			var identCols = _table.Columns.Where(a => a.Value.Attribute.IsIdentity == true);
 			if (identCols.Any() == false) {
-				await _orm.Ado.ExecuteNonQueryAsync(CommandType.Text, sql, _params);
+				await _orm.Ado.ExecuteNonQueryAsync(_transaction, CommandType.Text, sql, _params);
 				return 0;
 			}
-			return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0;
+			return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, " RETURNING ", _commonUtils.QuoteSqlName(identCols.First().Value.Attribute.Name)), _params)), out var trylng) ? trylng : 0;
 		}

 		public override List<T1> ExecuteInserted() {
@ -48,7 +48,7 @@ namespace FreeSql.PostgreSQL.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params);
+			return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
 		}
 		async public override Task<List<T1>> ExecuteInsertedAsync() {
 			var sql = this.ToSql();
@ -63,7 +63,7 @@ namespace FreeSql.PostgreSQL.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params);
+			return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
 		}
 	}
 }
--- a/FreeSql/PostgreSQL/Curd/PostgreSQLUpdate.cs
+++ b/FreeSql/PostgreSQL/Curd/PostgreSQLUpdate.cs
@ -27,7 +27,7 @@ namespace FreeSql.PostgreSQL.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
+			return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
 		}
 		async public override Task<List<T1>> ExecuteUpdatedAsync() {
 			var sql = this.ToSql();
@ -42,7 +42,7 @@ namespace FreeSql.PostgreSQL.Curd {
 				sb.Append(_commonUtils.QuoteReadColumn(col.CsType, _commonUtils.QuoteSqlName(col.Attribute.Name))).Append(" as ").Append(_commonUtils.QuoteSqlName(col.CsName));
 				++colidx;
 			}
-			return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
+			return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
 		}

 		protected override void ToSqlCase(StringBuilder caseWhen, ColumnInfo[] primarys) {
--- a/FreeSql/SqlServer/Curd/SqlServerDelete.cs
+++ b/FreeSql/SqlServer/Curd/SqlServerDelete.cs
@ -30,7 +30,7 @@ namespace FreeSql.SqlServer.Curd {
 			sb.Insert(0, sql.Substring(0, validx));
 			sb.Append(sql.Substring(validx));

-			return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params.ToArray());
+			return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
 		}
 		async public override Task<List<T1>> ExecuteDeletedAsync() {
 			var sql = this.ToSql();
@ -50,7 +50,7 @@ namespace FreeSql.SqlServer.Curd {
 			sb.Insert(0, sql.Substring(0, validx));
 			sb.Append(sql.Substring(validx));

-			return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params.ToArray());
+			return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.ToArray());
 		}
 	}
 }
--- a/FreeSql/SqlServer/Curd/SqlServerInsert.cs
+++ b/FreeSql/SqlServer/Curd/SqlServerInsert.cs
@ -16,13 +16,13 @@ namespace FreeSql.SqlServer.Curd {
 			var sql = this.ToSql();
 			if (string.IsNullOrEmpty(sql)) return 0;

-			return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0;
+			return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0;
 		}
 		async public override Task<long> ExecuteIdentityAsync() {
 			var sql = this.ToSql();
 			if (string.IsNullOrEmpty(sql)) return 0;

-			return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0;
+			return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, "; SELECT SCOPE_IDENTITY();"), _params)), out var trylng) ? trylng : 0;
 		}

 		public override List<T1> ExecuteInserted() {
@ -43,7 +43,7 @@ namespace FreeSql.SqlServer.Curd {
 			sb.Insert(0, sql.Substring(0, validx + 1));
 			sb.Append(sql.Substring(validx + 1));

-			return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params);
+			return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
 		}
 		async public override Task<List<T1>> ExecuteInsertedAsync() {
 			var sql = this.ToSql();
@ -63,7 +63,7 @@ namespace FreeSql.SqlServer.Curd {
 			sb.Insert(0, sql.Substring(0, validx + 1));
 			sb.Append(sql.Substring(validx + 1));

-			return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params);
+			return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params);
 		}
 	}
 }
--- a/FreeSql/SqlServer/Curd/SqlServerUpdate.cs
+++ b/FreeSql/SqlServer/Curd/SqlServerUpdate.cs
@ -33,7 +33,7 @@ namespace FreeSql.SqlServer.Curd {
 			sb.Insert(0, sql.Substring(0, validx));
 			sb.Append(sql.Substring(validx));

-			return _orm.Ado.Query<T1>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
+			return _orm.Ado.Query<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
 		}
 		async public override Task<List<T1>> ExecuteUpdatedAsync() {
 			var sql = this.ToSql();
@ -53,7 +53,7 @@ namespace FreeSql.SqlServer.Curd {
 			sb.Insert(0, sql.Substring(0, validx));
 			sb.Append(sql.Substring(validx));

-			return await _orm.Ado.QueryAsync<T1>(CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
+			return await _orm.Ado.QueryAsync<T1>(_transaction, CommandType.Text, sb.ToString(), _params.Concat(_paramsSource).ToArray());
 		}

 		protected override void ToSqlCase(StringBuilder caseWhen, ColumnInfo[] primarys) {
--- a/FreeSql/Sqlite/Curd/SqliteInsert.cs
+++ b/FreeSql/Sqlite/Curd/SqliteInsert.cs
@ -16,13 +16,13 @@ namespace FreeSql.Sqlite.Curd {
 			var sql = this.ToSql();
 			if (string.IsNullOrEmpty(sql)) return 0;

-			return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0;
+			return long.TryParse(string.Concat(_orm.Ado.ExecuteScalar(_transaction, CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0;
 		}
 		async public override Task<long> ExecuteIdentityAsync() {
 			var sql = this.ToSql();
 			if (string.IsNullOrEmpty(sql)) return 0;

-			return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0;
+			return long.TryParse(string.Concat(await _orm.Ado.ExecuteScalarAsync(_transaction, CommandType.Text, string.Concat(sql, "; SELECT last_insert_rowid();"), _params)), out var trylng) ? trylng : 0;
 		}

 		public override List<T1> ExecuteInserted() {
--- a/readme.md
+++ b/readme.md
@ -1,7 +1,7 @@
 FreeSql 是一个功能强大的 .NETStandard 库，用于对象关系映射程序(O/RM)，便于开发人员能够使用 .NETStandard 对象来处理数据库，不必经常编写大部分数据访问代码。支持 .NETCore 2.1+ 或 .NETFramework 4.6.1+。

-| Package Name |  NuGet | Downloads | |
-|--------------|  ------- |  ---- | -- |
+| Package Name |  NuGet | Downloads |
+|--------------|  ------- |  ---- |
 | FreeSql | [![nuget](https://img.shields.io/nuget/v/FreeSql.svg?style=flat-square)](https://www.nuget.org/packages/FreeSql) | [![stats](https://img.shields.io/nuget/dt/FreeSql.svg?style=flat-square)](https://www.nuget.org/stats/packages/FreeSql?groupby=Version) |
 | [FreeSql.Repository](https://github.com/2881099/FreeSql/wiki/Repository) | [![nuget](https://img.shields.io/nuget/v/FreeSql.Repository.svg?style=flat-square)](https://www.nuget.org/packages/FreeSql.Repository) | [![stats](https://img.shields.io/nuget/dt/FreeSql.Repository.svg?style=flat-square)](https://www.nuget.org/stats/packages/FreeSql.Repository?groupby=Version) |