替换测试一下链接关闭现象

代码/System.Common/Repositories/BaseRepository.cs

 {
     public class BaseRepository<T> : BaseContext, IRepository<T> where T : class, new()
     {
-        //public SimpleClient<T> CurrentDb => new SimpleClient<T>(Db);
+        public SimpleClient<T> CurrentDB => new SimpleClient<T>(Db);
 
         /// <summary>
         /// 获取数量
         public async Task<int> GetCount(Expression<Func<T, bool>> whereExpression = null)
         {
             if (whereExpression != null)
-                return await Db.Queryable<T>().With(SqlWith.NoLock).CountAsync(whereExpression);
+                return await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).CountAsync(whereExpression);
             else
-                return await Db.Queryable<T>().With(SqlWith.NoLock).CountAsync();
+                return await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).CountAsync();
         }
 
         /// <summary>
         /// <returns></returns>
         public async Task<List<T>> GetList()
         {
-            return await Db.Queryable<T>().With(SqlWith.NoLock).ToListAsync();
-            //return CurrentDb.GetList();
+            return await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).ToListAsync();
+            //return CurrentCurrentDB.GetList();
         }
         public async Task<List<T>> GetListALL(Expression<Func<T, bool>> whereExpression)
         {
-            return await Db.Queryable<T>().With(SqlWith.NoLock).Where(whereExpression).ToListAsync();
+            return await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).Where(whereExpression).ToListAsync();
         }
 
         public async Task<List<T>> GetListALL(List<IConditionalModel> conModels, string orderby)
         {
-            return await Db.Queryable<T>().With(SqlWith.NoLock).Where(conModels).OrderBy(orderby).ToListAsync();
+            return await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).Where(conModels).OrderBy(orderby).ToListAsync();
         }
 
         public async Task<List<T>> GetListALL(Expression<Func<T, bool>> whereExpression, Expression<Func<T, object>> orderExpression, OrderByType ordertype = OrderByType.Asc)
         {
-            return await Db.Queryable<T>().With(SqlWith.NoLock).Where(whereExpression).OrderBy(orderExpression, ordertype).ToListAsync();
+            return await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).Where(whereExpression).OrderBy(orderExpression, ordertype).ToListAsync();
         }
 
         /// <summary>
         /// <returns></returns>
         public async Task<PageData<T>> GetListByPage(List<IConditionalModel> conModels, MyPageModel pagemodel, string orderby)
         {
-            var list = await Db.Queryable<T>().With(SqlWith.NoLock).Where(conModels).OrderBy(orderby).ToPageListAsync(pagemodel.PageIndex, pagemodel.PageSize, pagemodel.PageCount);
+            var list = await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).Where(conModels).OrderBy(orderby).ToPageListAsync(pagemodel.PageIndex, pagemodel.PageSize, pagemodel.PageCount);
             PageData<T> pd = new PageData<T>();
             pd.Rows = list;
             pd.Totals = pagemodel.PageCount;
-            return pd;// CurrentDb.GetPageList(conModels, pagemodel);
+            return pd;// CurrentCurrentDB.GetPageList(conModels, pagemodel);
         }
 
         public async Task<PageData<T>> GetListByPage(List<IConditionalModel> conModels, MyPageModel pagemodel)
         {
-            var list = await Db.Queryable<T>().With(SqlWith.NoLock).Where(conModels).ToPageListAsync(pagemodel.PageIndex, pagemodel.PageSize, pagemodel.PageCount);
+            var list = await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).Where(conModels).ToPageListAsync(pagemodel.PageIndex, pagemodel.PageSize, pagemodel.PageCount);
             PageData<T> pd = new PageData<T>();
             pd.Rows = list;
             pd.Totals = pagemodel.PageCount;
-            return pd;// CurrentDb.GetPageList(conModels, pagemodel);
+            return pd;// CurrentCurrentDB.GetPageList(conModels, pagemodel);
         }
 
         public async Task<PageData<T>> GetListByPage(Expression<Func<T, bool>> whereExpression, MyPageModel pagemodel)
         {
-            var list = await Db.Queryable<T>().With(SqlWith.NoLock).Where(whereExpression).ToPageListAsync(pagemodel.PageIndex, pagemodel.PageSize, pagemodel.PageCount);
+            var list = await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).Where(whereExpression).ToPageListAsync(pagemodel.PageIndex, pagemodel.PageSize, pagemodel.PageCount);
             PageData<T> pd = new PageData<T>();
             pd.Rows = list;
             pd.Totals = pagemodel.PageCount;
-            return pd;// CurrentDb.GetPageList(conModels, pagemodel);
+            return pd;// CurrentCurrentDB.GetPageList(conModels, pagemodel);
         }
 
         public async Task<PageData<T>> GetListByPage(Expression<Func<T, bool>> whereExpression, MyPageModel pagemodel, string orderby)
         {
-            var list = await Db.Queryable<T>().With(SqlWith.NoLock).Where(whereExpression).OrderBy(orderby).ToPageListAsync(pagemodel.PageIndex, pagemodel.PageSize, pagemodel.PageCount);
+            var list = await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).Where(whereExpression).OrderBy(orderby).ToPageListAsync(pagemodel.PageIndex, pagemodel.PageSize, pagemodel.PageCount);
             PageData<T> pd = new PageData<T>();
             pd.Rows = list;
             pd.Totals = pagemodel.PageCount;
-            return pd;// CurrentDb.GetPageList(conModels, pagemodel);
+            return pd;// CurrentCurrentDB.GetPageList(conModels, pagemodel);
         }
 
         public async Task<T> GetSingle(Expression<Func<T, bool>> whereExpression)
         {
-            return await Db.Queryable<T>().With(SqlWith.NoLock).Where(whereExpression).SingleAsync();
-            //return CurrentDb.GetSingle(whereExpression);
+            return await CurrentDB.AsSugarClient().Queryable<T>().With(SqlWith.NoLock).Where(whereExpression).SingleAsync();
+            //return CurrentCurrentDB.GetSingle(whereExpression);
         }
 
         /// <summary>
         /// <returns></returns>
         public async Task<int> Add(T obj)
         {
-            return await Db.Insertable<T>(obj).ExecuteReturnIdentityAsync();
-            //return CurrentDb.InsertReturnIdentity(obj);
+            return await CurrentDB.AsSugarClient().Insertable<T>(obj).ExecuteReturnIdentityAsync();
+            //return CurrentCurrentDB.InsertReturnIdentity(obj);
         }
 
         /// <summary>
         /// <returns></returns>
         public async Task<bool> AddReturnCount(T obj)
         {
-            int res = await Db.Insertable<T>(obj).ExecuteCommandAsync();
+            int res = await CurrentDB.AsSugarClient().Insertable<T>(obj).ExecuteCommandAsync();
             return res > 0;
         }
 
         /// <returns></returns>
         public async Task<int> AddIgnore(T obj, Expression<Func<T, object>> IgnoreColumns)
         {
-            return await Db.Insertable<T>(obj).IgnoreColumns(IgnoreColumns).ExecuteReturnIdentityAsync();
-            //return CurrentDb.InsertReturnIdentity(obj);
+            return await CurrentDB.AsSugarClient().Insertable<T>(obj).IgnoreColumns(IgnoreColumns).ExecuteReturnIdentityAsync();
+            //return CurrentCurrentDB.InsertReturnIdentity(obj);
         }
 
         /// <summary>
         /// <returns></returns>
         public async Task<int> AddStrong(T obj, bool isStrong = false)
         {
-            return await Db.Insertable<T>(obj).IgnoreColumns(true, isStrong).ExecuteReturnIdentityAsync();
-            //return CurrentDb.InsertReturnIdentity(obj);
+            return await CurrentDB.AsSugarClient().Insertable<T>(obj).IgnoreColumns(true, isStrong).ExecuteReturnIdentityAsync();
+            //return CurrentCurrentDB.InsertReturnIdentity(obj);
         }
         /// <summary>
         /// 批量添加
         /// <returns></returns>
         public async Task<bool> AddMany(List<T> objlist)
         {
-            var res = await Db.Insertable<T>(objlist).ExecuteCommandAsync();
+            var res = await CurrentDB.AsSugarClient().Insertable<T>(objlist).ExecuteCommandAsync();
             return res > 0;
         }
 
         /// <returns></returns>
         public async Task<bool> Delete(Expression<Func<T, bool>> whereExpression)
         {
-            return await Db.Deleteable<T>(whereExpression).ExecuteCommandHasChangeAsync();
-            //return CurrentDb.Delete(whereExpression);
+            return await CurrentDB.AsSugarClient().Deleteable<T>(whereExpression).ExecuteCommandHasChangeAsync();
+            //return CurrentCurrentDB.Delete(whereExpression);
         }
 
         /// <summary>
         /// <returns></returns>
         public async Task<bool> Update(T obj)
         {
-            return await Db.Updateable<T>(obj).ExecuteCommandHasChangeAsync();
-            //return CurrentDb.Update(obj);
+            return await CurrentDB.AsSugarClient().Updateable<T>(obj).ExecuteCommandHasChangeAsync();
+            //return CurrentCurrentDB.Update(obj);
         }
         /// <summary>
         /// 条件更新
         /// <returns></returns>
         public async Task<bool> Update(Expression<Func<T, T>> UpdateColumnsExpression, Expression<Func<T, bool>> whereExpression)
         {
-            return await Db.Updateable<T>().SetColumns(UpdateColumnsExpression).Where(whereExpression).ExecuteCommandHasChangeAsync();
-            //return CurrentDb.Update(obj);
+            return await CurrentDB.AsSugarClient().Updateable<T>().SetColumns(UpdateColumnsExpression).Where(whereExpression).ExecuteCommandHasChangeAsync();
+            //return CurrentCurrentDB.Update(obj);
         }
         /// <summary>
         /// 批量整条更新
         /// <returns></returns>
         public async Task<bool> UpdateList(List<T> obj)
         {
-            return await Db.Updateable<T>(obj).ExecuteCommandHasChangeAsync();
-            //return CurrentDb.Update(obj);
+            return await CurrentDB.AsSugarClient().Updateable<T>(obj).ExecuteCommandHasChangeAsync();
+            //return CurrentCurrentDB.Update(obj);
         }
 
         public Data.DataTable GetTableSugar(string sql, SugarParameter[] sugarParameter = null)
         {
             if (sugarParameter == null)
-            { return Db.Ado.GetDataTable(sql); }
+            { return CurrentDB.AsSugarClient().Ado.GetDataTable(sql); }
             else
-            { return Db.Ado.GetDataTable(sql, sugarParameter); }
+            { return CurrentDB.AsSugarClient().Ado.GetDataTable(sql, sugarParameter); }
         }
 
         public int ExecuteCommandSugar(string sql,SugarParameter[] sugarParameter=null)
         {
             if (sugarParameter == null)
-            { return Db.Ado.ExecuteCommand(sql); }
+            { return CurrentDB.AsSugarClient().Ado.ExecuteCommand(sql); }
             else
-            { return Db.Ado.ExecuteCommand(sql, sugarParameter); }
+            { return CurrentDB.AsSugarClient().Ado.ExecuteCommand(sql, sugarParameter); }
         }
 
         /// <summary>
         [Obsolete]
         public async Task<bool> UpdateListToColumns(List<T> obj, Expression<Func<T, object>> objColumns)
         {
-            return await Db.Updateable<T>(obj).UpdateColumns(objColumns).ExecuteCommandHasChangeAsync();
-            //return CurrentDb.Update(obj);
+            return await CurrentDB.AsSugarClient().Updateable<T>(obj).UpdateColumns(objColumns).ExecuteCommandHasChangeAsync();
+            //return CurrentCurrentDB.Update(obj);
         }
     }
 }