修改

Net6Demo_Api.Business/BaseBusiness.cs

@@ -218,40 +218,72 @@ namespace Net6Demo_Api.Business
         /// 更新一条数据
         /// </summary>
         /// <param name="entity">实体对象</param>
-        public int Update(T entity)
+        /// <param name="properties">更新的实体属性</param>
+        public int Update(T entity, List<string> properties = null)
         {
             if (IsCache) OutRedis().Wait();
-            return _db.Update(entity);
+            if (properties == null || properties.Count == 0)
+            {
+                return _db.Update(entity);
+            }
+            else
+            {
+                return _db.Update(entity, properties);
+            }
         }
 
         /// <summary>
         /// 更新一条数据
         /// </summary>
         /// <param name="entity">实体对象</param>
-        public async Task<int> UpdateAsync(T entity)
+        /// <param name="properties">更新的实体属性</param>
+        public async Task<int> UpdateAsync(T entity, List<string> properties = null)
         {
             if (IsCache) await OutRedis();
-            return await _db.UpdateAsync(entity);
+            if (properties == null || properties.Count == 0)
+            {
+                return await _db.UpdateAsync(entity);
+            }
+            else
+            {
+                return await _db.UpdateAsync(entity, properties);
+            }
         }
 
         /// <summary>
         /// 更新多条数据
         /// </summary>
         /// <param name="entities">数据列表</param>
-        public int Update(List<T> entities)
+        /// <param name="properties">更新的实体属性</param>
+        public int Update(List<T> entities, List<string> properties = null)
         {
             if (IsCache) OutRedis().Wait();
-            return _db.Update(entities);
+            if (properties == null || properties.Count == 0)
+            {
+                return _db.Update(entities);
+            }
+            else
+            {
+                return _db.Update(entities, properties);
+            }
         }
 
         /// <summary>
         /// 更新多条数据
         /// </summary>
         /// <param name="entities">数据列表</param>
-        public async Task<int> UpdateAsync(List<T> entities)
+        /// <param name="properties">更新的实体属性</param>
+        public async Task<int> UpdateAsync(List<T> entities, List<string> properties = null)
         {
             if (IsCache) await OutRedis();
-            return await _db.UpdateAsync(entities);
+            if (properties == null || properties.Count == 0)
+            {
+                return await _db.UpdateAsync(entities);
+            }
+            else
+            {
+                return await _db.UpdateAsync(entities, properties);
+            }
         }
 
         /// <summary>
@@ -331,7 +363,7 @@ namespace Net6Demo_Api.Business
                 var listCache = GetRedis().Result;
                 if (listCache != null)
                 {
-                    return listCache.AsQueryable().Where(p=> KeyFiled.GetValue(p).ToString() == keyValue[0].ToString()).FirstOrDefault();
+                    return listCache.AsQueryable().Where(p => KeyFiled.GetValue(p).ToString() == keyValue[0].ToString()).FirstOrDefault();
                 }
             }
             #endregion
@@ -348,7 +380,7 @@ namespace Net6Demo_Api.Business
             #region 启用缓存
             if (IsCache)
             {
-                var listCache =await GetRedis();
+                var listCache = await GetRedis();
                 if (listCache != null)
                 {
                     return listCache.AsQueryable().Where(p => KeyFiled.GetValue(p).ToString() == keyValue[0].ToString()).FirstOrDefault();
@@ -360,40 +392,149 @@ namespace Net6Demo_Api.Business
         }
 
         /// <summary>
-        /// 分页获取数据
+        /// 根据条件获取数量
         /// </summary>
-        /// <param name="page">分页信息</param>
-        /// <param name="orderByString">排序</param>
-        /// <param name="condition">条件</param>
         /// <returns></returns>
-        public async Task<ValueTuple<List<T>, int>> GetListPageAsync(PageInput page, string orderByString, Expression<Func<T, bool>> condition)
+        public int GetCount(Expression<Func<T, bool>> condition)
         {
-            var iq = GetIQueryable().Where(condition);
-            var list = await iq.OrderBy(orderByString).Skip((page.PageIndex - 1) * page.PageRows).Take(page.PageRows).ToListAsync();
-            int total = await iq.CountAsync();
+            #region 启用缓存
+            if (IsCache)
+            {
+                var listCache = GetRedis().Result;
+                if (listCache != null)
+                {
+                    return listCache.AsQueryable().Where(condition).Count();
+                }
+            }
+            #endregion
 
-            return (list, total);
+            return _db.GetIQueryable<T>().AsNoTracking().Where(condition).Count();
         }
 
         /// <summary>
-        /// 获取实体对应的表，延迟加载，主要用于支持Linq查询操作
+        /// 根据条件获取数量
+        /// </summary>
+        /// <returns></returns>
+        public async Task<int> GetCountAsync(Expression<Func<T, bool>> condition)
+        {
+            #region 启用缓存
+            if (IsCache)
+            {
+                var listCache = await GetRedis();
+                if (listCache != null)
+                {
+                    return listCache.AsQueryable().Where(condition).Count();
+                }
+            }
+            #endregion
+
+            return await _db.GetIQueryable<T>().AsNoTracking().Where(condition).CountAsync();
+        }
+
+        /// <summary>
+        /// 获取表的所有数据，当数据量很大时不要使用！
+        /// </summary>
+        /// <returns></returns>
+        public List<T> GetList()
+        {
+            #region 启用缓存
+            if (IsCache)
+            {
+                var listCache = GetRedis().Result;
+                if (listCache != null)
+                {
+                    return listCache;
+                }
+            }
+            #endregion
+            return _db.GetIQueryable<T>().AsNoTracking().ToList();
+        }
+
+        /// <summary>
+        /// 根据条件获取列表，当数据量很大时不要使用！
         /// </summary>
-        /// <param name="IsNoCache">默认false，需要关联表查询时用true</param>
+        /// <param name="condition">条件</param>
         /// <returns></returns>
-        public IQueryable<T> GetIQueryable(bool IsNoCache = false)
+        public List<T> GetList(Expression<Func<T, bool>> condition)
         {
             #region 启用缓存
-            if (IsCache && !IsNoCache)
+            if (IsCache)
             {
                 var listCache = GetRedis().Result;
                 if (listCache != null)
                 {
-                    return listCache.AsQueryable();
+                    return listCache.AsQueryable().Where(condition).ToList();
                 }
             }
             #endregion
 
-            return _db.GetIQueryable<T>().AsNoTracking();
+            return _db.GetIQueryable<T>().AsNoTracking().Where(condition).ToList();
+        }
+
+        /// <summary>
+        /// 获取表的所有数据，当数据量很大时不要使用！
+        /// </summary>
+        /// <returns></returns>
+        public async Task<List<T>> GetListAsync()
+        {
+            #region 启用缓存
+            if (IsCache)
+            {
+                var listCache = await GetRedis();
+                if (listCache != null)
+                {
+                    return listCache;
+                }
+            }
+            #endregion
+            return await _db.GetIQueryable<T>().AsNoTracking().ToListAsync();
+        }
+
+        /// <summary>
+        /// 根据条件获取列表，当数据量很大时不要使用！
+        /// </summary>
+        /// <param name="condition">条件</param>
+        /// <returns></returns>
+        public async Task<List<T>> GetListAsync(Expression<Func<T, bool>> condition)
+        {
+            #region 启用缓存
+            if (IsCache)
+            {
+                var listCache = await GetRedis();
+                if (listCache != null)
+                {
+                    return listCache.AsQueryable().Where(condition).ToList();
+                }
+            }
+            #endregion
+
+            return await _db.GetIQueryable<T>().AsNoTracking().Where(condition).ToListAsync();
+        }
+
+        /// <summary>
+        /// 分页获取数据
+        /// </summary>
+        /// <param name="page">分页信息</param>
+        /// <param name="orderByString">排序</param>
+        /// <param name="condition">条件</param>
+        /// <returns></returns>
+        public async Task<ValueTuple<List<T>, int>> GetListPageAsync(PageInput page, string orderByString, Expression<Func<T, bool>> condition)
+        {
+            var iq = _db.GetIQueryable<T>().AsNoTracking().Where(condition).OrderBy(orderByString);
+
+            var list = await iq.Skip((page.PageIndex - 1) * page.PageRows).Take(page.PageRows).ToListAsync();
+            int total = await iq.CountAsync();
+
+            return (list, total);
+        }
+
+        /// <summary>
+        /// 获取实体对应的表，延迟加载，主要用于支持Linq查询操作
+        /// </summary>
+        /// <returns></returns>
+        public virtual IQueryable<T> GetIQueryable()
+        {
+            return _db.GetIQueryable<T>();
         }
 
         #endregion

Net6Demo_Api.IBusiness/IBaseBusiness.cs

@@ -108,13 +108,15 @@ namespace Net6Demo_Api.IBusiness
         /// 更新一条数据
         /// </summary>
         /// <param name="entity">实体对象</param>
-        int Update(T entity);
+        /// <param name="properties">更新的实体属性</param>
+        int Update(T entity, List<string> properties = null);
 
         /// <summary>
         /// 更新一条数据
         /// </summary>
         /// <param name="entity">实体对象</param>
-        Task<int> UpdateAsync(T entity);
+        /// <param name="properties">更新的实体属性</param>
+        Task<int> UpdateAsync(T entity, List<string> properties = null);
 
         /// <summary>
         /// 指定条件更新
@@ -168,20 +170,53 @@ namespace Net6Demo_Api.IBusiness
         Task<T> GetEntityAsync(params object[] keyValue);
 
         /// <summary>
-        /// 分页获取数据
+        /// 根据条件获取数量
         /// </summary>
-        /// <param name="page">分页信息</param>
-        /// <param name="orderByString">排序</param>
         /// <param name="condition">条件</param>
         /// <returns></returns>
-        Task<ValueTuple<List<T>, int>> GetListPageAsync(PageInput page, string orderByString, Expression<Func<T, bool>> condition);
+        int GetCount(Expression<Func<T, bool>> condition);
+
+        /// <summary>
+        /// 根据条件获取数量
+        /// </summary>
+        /// <param name="condition">条件</param>
+        /// <returns></returns>
+        Task<int> GetCountAsync(Expression<Func<T, bool>> condition);
+
+        /// <summary>
+        /// 获取表的所有数据，当数据量很大时不要使用！
+        /// </summary>
+        /// <returns></returns>
+        List<T> GetList();
+
+        /// <summary>
+        /// 根据条件获取列表，当数据量很大时不要使用！
+        /// </summary>
+        /// <param name="condition">条件</param>
+        /// <returns></returns>
+        List<T> GetList(Expression<Func<T, bool>> condition);
+
+        /// <summary>
+        /// 获取表的所有数据，当数据量很大时不要使用！
+        /// </summary>
+        /// <returns></returns>
+        Task<List<T>> GetListAsync();
+
+        /// <summary>
+        /// 根据条件获取列表，当数据量很大时不要使用！
+        /// </summary>
+        /// <param name="condition">条件</param>
+        /// <returns></returns>
+        Task<List<T>> GetListAsync(Expression<Func<T, bool>> condition);
 
         /// <summary>
-        /// 获取实体对应的表，延迟加载，主要用于支持Linq查询操作
+        /// 分页获取数据
         /// </summary>
-        /// <param name="IsNoCache">默认false，需要关联表查询时用true</param>
+        /// <param name="page">分页信息</param>
+        /// <param name="orderByString">排序</param>
+        /// <param name="condition">条件</param>
         /// <returns></returns>
-        IQueryable<T> GetIQueryable(bool IsNoCache = false);
+        Task<ValueTuple<List<T>, int>> GetListPageAsync(PageInput page, string orderByString, Expression<Func<T, bool>> condition);
 
         #endregion
 

Net6Demo_Api/Controllers/HomeController.cs

@@ -93,7 +93,7 @@ namespace Net6Demo_Api.Controllers
         [HttpPost]
         public async Task<ActionResult> SubmitLogin(LoginInput input)
         {
-            var user = await _userBus.GetIQueryable().Where(p => p.F_UserCode == input.usercode && p.F_Password == input.password.ToMD5String()).FirstOrDefaultAsync();
+            var user = (await _userBus.GetListAsync(p => p.F_UserCode == input.usercode && p.F_Password == input.password.ToMD5String())).FirstOrDefault();
 
             if (user == null)
             {
@@ -105,9 +105,11 @@ namespace Net6Demo_Api.Controllers
             }
 
             //await _userBus.ExecuteSqlAsync("update T_Sys_UserAccount set F_LastActiveTime=SYSDATE() where F_UserId=" + user.F_UserId);
-            Dictionary<string, object?> param = new Dictionary<string, object?>();
-            param.Add("F_LastActiveTime",DateTime.Now);
-            await _userBus.UpdateSqlAsync(p => p.F_UserId == user.F_UserId, param);
+            //Dictionary<string, object?> param = new Dictionary<string, object?>();
+            //param.Add("F_LastActiveTime",DateTime.Now);
+            //await _userBus.UpdateSqlAsync(p => p.F_UserId == user.F_UserId, param);
+            user.F_LastActiveTime = DateTime.Now;
+            await _userBus.UpdateAsync(user, new List<string>() { "F_LastActiveTime" });
 
             var claims = new[]
             {

Net6Demo_Api/Controllers/IndexController.cs

@@ -40,8 +40,8 @@ namespace Net6Demo_Api.Controllers
         [HttpGet]
         public async Task<ActionResult> GetMenu()
         {
-            var mids = await _roleMenuBus.GetIQueryable().Where(p => p.F_RoleId == CurrentUser.RoleId).Select(p => p.F_MenuId).ToListAsync();
-            var menus = _mapper.Map<List<MenuTreeView>>(await _menuBus.GetIQueryable().Where(p => mids.Contains(p.F_MenuId) && p.F_State == 1).ToListAsync());
+            var mids = (await _roleMenuBus.GetListAsync(p => p.F_RoleId == CurrentUser.RoleId)).Select(p => p.F_MenuId).ToList();
+            var menus = _mapper.Map<List<MenuTreeView>>((await _menuBus.GetListAsync(p => mids.Contains(p.F_MenuId) && p.F_State == 1)).ToList());
             return Success("成功", GetTreeList(menus));
 
             List<MenuTreeView> GetTreeList(List<MenuTreeView> list, int parentId = 0)

Net6Demo_Api/Controllers/System/CustomFiledController.cs

@@ -27,7 +27,7 @@ namespace Net6Demo_Api.Controllers
         [HttpGet]
         public async Task<ActionResult> GetData(string tableid)
         {
-            var data = await _configBus.GetIQueryable().Where(p => p.F_TableId == tableid && p.F_CreateUser == CurrentUser.UserCode).FirstOrDefaultAsync();
+            var data = (await _configBus.GetListAsync(p => p.F_TableId == tableid && p.F_CreateUser == CurrentUser.UserCode)).FirstOrDefault();
             if (data != null)
             {
                 return Success("成功", _mapper.Map<CustomFiledView>(data));
@@ -46,7 +46,7 @@ namespace Net6Demo_Api.Controllers
         public async Task<ActionResult> SaveData(CustomFiledAddEditInput input)
         {
             int result = 0;
-            var oldData = await _configBus.GetIQueryable().Where(p => p.F_TableId == input.TableId && p.F_CreateUser == CurrentUser.UserCode).FirstOrDefaultAsync();
+            var oldData = (await _configBus.GetListAsync(p => p.F_TableId == input.TableId && p.F_CreateUser == CurrentUser.UserCode)).FirstOrDefault();
             if (oldData != null)
             {
                 _mapper.Map(input, oldData);

Net6Demo_Api/Controllers/System/DepartmentController.cs

@@ -58,7 +58,7 @@ namespace Net6Demo_Api.Controllers
         [HttpGet]
         public async Task<ActionResult> GetTreeList()
         {
-            var depts = _mapper.Map<List<DepartmentTreeView>>(await _deptBus.GetIQueryable().Where(p => p.F_State == 1).ToListAsync());
+            var depts = _mapper.Map<List<DepartmentTreeView>>(await _deptBus.GetListAsync(p => p.F_State == 1));
             return Success("成功", GetTreeList(depts));
 
             List<DepartmentTreeView> GetTreeList(List<DepartmentTreeView> list, int parentId = 0)

Net6Demo_Api/Controllers/System/RoleController.cs

@@ -155,8 +155,8 @@ namespace Net6Demo_Api.Controllers
         [HttpGet]
         public async Task<ActionResult> GetRoleMenu(int roleid)
         {
-            var rolemenuids = await _roleMenuBus.GetIQueryable().Where(p => p.F_RoleId == roleid).Select(p => p.F_MenuId).ToListAsync();
-            var menus = await _menuBus.GetIQueryable().Where(p => p.F_State == 1).ToListAsync();
+            var rolemenuids = (await _roleMenuBus.GetListAsync(p => p.F_RoleId == roleid)).Select(p => p.F_MenuId).ToList();
+            var menus = await _menuBus.GetListAsync(p => p.F_State == 1);
             var result = menus.Select(x => new
             {
                 id = x.F_MenuId,

Net6Demo_Api/Controllers/System/UserAccountController.cs

@@ -80,7 +80,7 @@ namespace Net6Demo_Api.Controllers
                 q = q.And(x => EF.Functions.Like(x.F_UserName, "%" + input.username + "%"));
             }
 
-            var result = await _userBus.GetIQueryable().Where(q).ToListAsync();
+            var result = await _userBus.GetListAsync(q);
             return Success("成功", _mapper.Map<List<UserAccountView>>(result));
         }
         /// <summary>

Net6Demo_Api/Filters/AuthorityFilter.cs

@@ -64,12 +64,12 @@ namespace Net6Demo_Api.Filters
                             string usercode = cls.Where(x => x.Type == "UserCode").FirstOrDefault()?.Value??"";
                             string roleid = cls.Where(x => x.Type == "RoleId").FirstOrDefault()?.Value ?? "";
                             //判断用户存在和角色是否改变
-                            var user = await _userBus.GetIQueryable().Where(p => p.F_UserCode == usercode && p.F_DeleteFlag == 0).FirstOrDefaultAsync(); 
+                            var user = (await _userBus.GetListAsync(p => p.F_UserCode == usercode && p.F_DeleteFlag == 0)).FirstOrDefault(); 
                             if (user != null && user.F_RoleId.ToString() == roleid)
                             {
                                 //判断此请求是否需要授权
                                 var path = ad.RouteValues["controller"] + "/" + ad.RouteValues["action"];
-                                var mid = await _menuBus.GetIQueryable().Where(p => p.F_State == 1 && p.F_Action == path).Select(p => p.F_MenuId).FirstOrDefaultAsync();
+                                var mid = (await _menuBus.GetListAsync(p => p.F_State == 1 && p.F_Action == path)).Select(p => p.F_MenuId).FirstOrDefault();
                                 if (mid > 0)
                                 {
                                     //判断此角色是否有权限