增加 UnitOfWorkManager 类管理工作单元，移除 FreeSql.UnitOfWork.Current 静态属性；

FreeSql.DbContext/FreeSql.DbContext.xml

@@ -227,6 +227,41 @@
             <param name="asTable">分表规则，参数：旧表名；返回：新表名 https://github.com/2881099/FreeSql/wiki/Repository</param>
             <returns></returns>
         </member>
+        <member name="T:FreeSql.RepositoryUnitOfWorkManager">
+            <summary>
+            仓储的工作单元管理器
+            </summary>
+        </member>
+        <member name="F:FreeSql.RepositoryUnitOfWorkManager.Propagation.Requierd">
+            <summary>
+            如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，默认的选择。
+            </summary>
+        </member>
+        <member name="F:FreeSql.RepositoryUnitOfWorkManager.Propagation.Supports">
+            <summary>
+            支持当前事务，如果没有当前事务，就以非事务方法执行。
+            </summary>
+        </member>
+        <member name="F:FreeSql.RepositoryUnitOfWorkManager.Propagation.Mandatory">
+            <summary>
+            使用当前事务，如果没有当前事务，就抛出异常。
+            </summary>
+        </member>
+        <member name="F:FreeSql.RepositoryUnitOfWorkManager.Propagation.NotSupported">
+            <summary>
+            以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
+            </summary>
+        </member>
+        <member name="F:FreeSql.RepositoryUnitOfWorkManager.Propagation.Never">
+            <summary>
+            以非事务方式执行操作，如果当前事务存在则抛出异常。
+            </summary>
+        </member>
+        <member name="F:FreeSql.RepositoryUnitOfWorkManager.Propagation.Nested">
+            <summary>
+            如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，就新建一个事务。
+            </summary>
+        </member>
         <member name="M:FreeSql.IDataFilter`1.Enable(System.String[])">
             <summary>
             开启过滤器，若使用 using 则使用完后，恢复为原有状态
@@ -299,6 +334,11 @@
             <param name="entity">实体对象</param>
             <param name="propertyName">属性名</param>
         </member>
+        <member name="T:FreeSql.IUnitOfWork">
+            <summary>
+            工作单元
+            </summary>
+        </member>
         <member name="M:FreeSql.IUnitOfWork.GetOrBeginTransaction(System.Boolean)">
             <summary>
             开启事务，或者返回已开启的事务
@@ -326,7 +366,7 @@
         </member>
         <member name="P:FreeSql.IUnitOfWork.EntityChangeReport">
             <summary>
-            此工作单元内的实体变化跟踪
+            工作单元内的实体变化跟踪
             </summary>
         </member>
         <member name="P:FreeSql.UnitOfWork.DebugBeingUsed">

FreeSql.DbContext/Repository/ContextSet/RepositoryUnitOfWorkManager.cs

@@ -0,0 +1,201 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading;
+
+namespace FreeSql
+{
+    /// <summary>
+    /// 仓储的工作单元管理器
+    /// </summary>
+    public class RepositoryUnitOfWorkManager : IDisposable
+    {
+        IFreeSql _fsql;
+        List<IRepositoryUnitOfWork> _uows = new List<IRepositoryUnitOfWork>();
+        bool _isNotSupported = false;
+
+        public RepositoryUnitOfWorkManager(IFreeSql fsql)
+        {
+            _fsql = fsql ?? throw new ArgumentNullException($"{nameof(RepositoryUnitOfWorkManager)} 构造参数 {nameof(fsql)} 不能为 null");
+        }
+
+        ~RepositoryUnitOfWorkManager() => this.Dispose();
+        int _disposeCounter;
+        public void Dispose()
+        {
+            if (Interlocked.Increment(ref _disposeCounter) != 1) return;
+            try
+            {
+                Exception exception = null;
+                for (var a = _uows.Count - 1; a >= 0; a--)
+                {
+                    try
+                    {
+                        if (exception == null) _uows[a].Commit();
+                        else _uows[a].Rollback();
+                    }
+                    catch (Exception ex)
+                    {
+                        if (exception == null) exception = ex;
+                    }
+                }
+                if (exception != null) throw exception;
+            }
+            finally
+            {
+                _uows.Clear();
+                GC.SuppressFinalize(this);
+            }
+        }
+
+        public enum Propagation
+        {
+            /// <summary>
+            /// 如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，默认的选择。
+            /// </summary>
+            Requierd,
+            /// <summary>
+            /// 支持当前事务，如果没有当前事务，就以非事务方法执行。
+            /// </summary>
+            Supports,
+            /// <summary>
+            /// 使用当前事务，如果没有当前事务，就抛出异常。
+            /// </summary>
+            Mandatory,
+            /// <summary>
+            /// 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
+            /// </summary>
+            NotSupported,
+            /// <summary>
+            /// 以非事务方式执行操作，如果当前事务存在则抛出异常。
+            /// </summary>
+            Never,
+            /// <summary>
+            /// 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，就新建一个事务。
+            /// </summary>
+            Nested
+        }
+
+        public IRepositoryUnitOfWork Begin(Propagation propagation, IsolationLevel? isolationLevel = null)
+        {
+            if (propagation == Propagation.Requierd)
+            {
+                if (_isNotSupported == false)
+                {
+                    for (var a = _uows.Count - 1; a >= 0; a--)
+                        if (_uows[a].GetOrBeginTransaction(false) != null)
+                            return new UnitOfWorkProxy(_uows[a]);
+                }
+                var uow = new RepositoryUnitOfWork(_fsql);
+                if (isolationLevel != null) uow.IsolationLevel = isolationLevel.Value;
+                try { uow.GetOrBeginTransaction(); }
+                catch { uow.Dispose(); throw; }
+                _uows.Add(uow);
+                return uow;
+            }
+            if (propagation == Propagation.Supports)
+            {
+                if (_isNotSupported == false)
+                {
+                    for (var a = _uows.Count - 1; a >= 0; a--)
+                        if (_uows[a].GetOrBeginTransaction(false) != null)
+                            return new UnitOfWorkProxy(_uows[a]);
+                }
+                return new UnitOfWorkNothing(_fsql);
+            }
+            if (propagation == Propagation.Mandatory)
+            {
+                if (_isNotSupported == false)
+                {
+                    for (var a = _uows.Count - 1; a >= 0; a--)
+                        if (_uows[a].GetOrBeginTransaction(false) != null)
+                            return new UnitOfWorkProxy(_uows[a]);
+                    throw new Exception("Propagation_Mandatory: 使用当前事务，如果没有当前事务，就抛出异常");
+                }
+                throw new Exception("Propagation_Mandatory: 使用当前事务，如果没有当前事务，就抛出异常（NotSupported 事务挂起中）");
+            }
+            if (propagation == Propagation.NotSupported)
+            {
+                if (_isNotSupported == false)
+                {
+                    _isNotSupported = true;
+                    return new UnitOfWorkNothing(_fsql) { OnDispose = () => _isNotSupported = false };
+                }
+                return new UnitOfWorkNothing(_fsql);
+            }
+            if (propagation == Propagation.Never)
+            {
+                if (_isNotSupported == false)
+                {
+                    for (var a = _uows.Count - 1; a >= 0; a--)
+                        if (_uows[a].GetOrBeginTransaction(false) != null)
+                            throw new Exception("Propagation_Never: 以非事务方式执行操作，如果当前事务存在则抛出异常");
+                }
+                return new UnitOfWorkNothing(_fsql);
+            }
+            if (propagation == Propagation.Nested)
+            {
+                var uow = new RepositoryUnitOfWork(_fsql);
+                if (isolationLevel != null) uow.IsolationLevel = isolationLevel.Value;
+                try { uow.GetOrBeginTransaction(); }
+                catch { uow.Dispose(); throw; }
+                _uows.Add(uow);
+                return uow;
+            }
+            throw new NotImplementedException();
+        }
+
+        class UnitOfWorkProxy : IRepositoryUnitOfWork
+        {
+            IRepositoryUnitOfWork _baseUow;
+            public UnitOfWorkProxy(IRepositoryUnitOfWork baseUow) => _baseUow = baseUow;
+            public IsolationLevel? IsolationLevel { get => _baseUow.IsolationLevel; set { } }
+            public DbContext.EntityChangeReport EntityChangeReport => _baseUow.EntityChangeReport;
+
+            public bool Enable => _baseUow.Enable;
+            public void Close() => _baseUow.Close();
+            public void Open() => _baseUow.Open();
+
+            public DbTransaction GetOrBeginTransaction(bool isCreate = true) => _baseUow.GetOrBeginTransaction(isCreate);
+            public void Commit() => this.Dispose();
+            public void Rollback() => _baseUow.Rollback();
+            public void Dispose() { }
+
+            public IBaseRepository<TEntity, TKey> GetRepository<TEntity, TKey>(Expression<Func<TEntity, bool>> filter = null) where TEntity : class => _baseUow.GetRepository<TEntity, TKey>(filter);
+            public IBaseRepository<TEntity> GetRepository<TEntity>(Expression<Func<TEntity, bool>> filter = null) where TEntity : class => _baseUow.GetRepository<TEntity>(filter);
+            public IBaseRepository<TEntity, Guid> GetGuidRepository<TEntity>(Expression<Func<TEntity, bool>> filter = null, Func<string, string> asTable = null) where TEntity : class => _baseUow.GetGuidRepository<TEntity>(filter);
+        }
+        class UnitOfWorkNothing : IRepositoryUnitOfWork
+        {
+            internal IFreeSql _fsql;
+            internal Action OnDispose;
+            public UnitOfWorkNothing(IFreeSql fsql) => _fsql = fsql;
+            public IsolationLevel? IsolationLevel { get; set; }
+            public DbContext.EntityChangeReport EntityChangeReport { get; } = new DbContext.EntityChangeReport();
+
+            public bool Enable { get; }
+            public void Close() { }
+            public void Open() { }
+
+            public DbTransaction GetOrBeginTransaction(bool isCreate = true) => null;
+            public void Commit()
+            {
+                if (EntityChangeReport != null && EntityChangeReport.OnChange != null && EntityChangeReport.Report.Any() == true)
+                    EntityChangeReport.OnChange.Invoke(EntityChangeReport.Report);
+                this.Dispose();
+            }
+            public void Rollback() => this.Dispose();
+            public void Dispose() {
+                EntityChangeReport?.Report.Clear();
+                OnDispose?.Invoke();
+            }
+
+            public IBaseRepository<TEntity, TKey> GetRepository<TEntity, TKey>(Expression<Func<TEntity, bool>> filter = null) where TEntity : class => new DefaultRepository<TEntity, TKey>(_fsql, filter);
+            public IBaseRepository<TEntity> GetRepository<TEntity>(Expression<Func<TEntity, bool>> filter = null) where TEntity : class => new DefaultRepository<TEntity,  int>(_fsql, filter);
+            public IBaseRepository<TEntity, Guid> GetGuidRepository<TEntity>(Expression<Func<TEntity, bool>> filter = null, Func<string, string> asTable = null) where TEntity : class => new GuidRepository<TEntity>(_fsql, filter, asTable);
+        }
+    }
+}

FreeSql.DbContext/UnitOfWork/IUnitOfWork.cs

@@ -5,6 +5,9 @@ using System.Data.Common;
 
 namespace FreeSql
 {
+    /// <summary>
+    /// 工作单元
+    /// </summary>
     public interface IUnitOfWork : IDisposable
     {
 
@@ -40,7 +43,7 @@ namespace FreeSql
         void Open();
 
         /// <summary>
-        /// 此工作单元内的实体变化跟踪
+        /// 工作单元内的实体变化跟踪
         /// </summary>
         DbContext.EntityChangeReport EntityChangeReport { get; }
     }

FreeSql.DbContext/UnitOfWork/UnitOfWork.cs

@@ -11,10 +11,6 @@ namespace FreeSql
 {
     public class UnitOfWork : IUnitOfWork
     {
-#if netcoreapp
-        public static readonly AsyncLocal<IUnitOfWork> Current = new AsyncLocal<IUnitOfWork>();
-#endif
-
         static int _seed;
         /// <summary>
         /// 正在使用中的工作单元（调试）
@@ -40,11 +36,7 @@ namespace FreeSql
             if (_fsql == null) throw new ArgumentNullException(nameof(fsql));
 
             _uowBefore = new Aop.TraceBeforeEventArgs("UnitOfWork", null);
-            _fsql?.Aop.TraceBeforeHandler?.Invoke(this, _uowBefore);
-
-#if netcoreapp
-            Current.Value = this;
-#endif
+            _fsql.Aop.TraceBeforeHandler?.Invoke(this, _uowBefore);
         }
 
         void ReturnObject()
@@ -55,9 +47,6 @@ namespace FreeSql
             _fsql.Ado.MasterPool.Return(_conn);
             _tran = null;
             _conn = null;
-#if netcoreapp
-            Current.Value = null;
-#endif
             EntityChangeReport?.Report.Clear();
         }
 
@@ -174,7 +163,6 @@ namespace FreeSql
             try
             {
                 this.Rollback();
-                this.Close();
             }
             finally
             {