diff --git a/CoreCms.Net.IRepository/IBaseRepository.cs b/CoreCms.Net.IRepository/IBaseRepository.cs
index f8a8cb9c..24658ace 100644
--- a/CoreCms.Net.IRepository/IBaseRepository.cs
+++ b/CoreCms.Net.IRepository/IBaseRepository.cs
@@ -32,7 +32,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="pkValue">主键值</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体</returns>
         T QueryById(object pkValue, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -42,7 +42,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="objId"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<T> QueryByIdAsync(object objId, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -52,7 +52,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="lstIds"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         List<T> QueryByIDs(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -62,7 +62,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="lstIds"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> QueryByIDsAsync(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -72,7 +72,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="lstIds"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         List<T> QueryByIDs(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -82,7 +82,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="lstIds"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> QueryByIDsAsync(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -91,7 +91,7 @@ namespace CoreCms.Net.IRepository
         /// </summary>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         List<T> Query(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -100,7 +100,7 @@ namespace CoreCms.Net.IRepository
         /// </summary>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> QueryAsync(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -111,7 +111,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderBy">排序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         List<T> QueryListByClause(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -122,7 +122,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderBy">排序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         Task<List<T>> QueryListByClauseAsync(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -133,7 +133,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderBy">排序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         List<T> QueryListByClause(Expression<Func<T, bool>> predicate, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -144,7 +144,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderBy">排序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, string orderBy = "",
             bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -157,7 +157,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         List<T> QueryListByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
             OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -170,7 +170,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate,
             Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -184,7 +184,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take,
             Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -198,7 +198,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take,
             Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -211,7 +211,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take, string strOrderByFields = "",
             bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -224,7 +224,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take,
             string strOrderByFields = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -235,7 +235,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         T QueryByClause(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -245,7 +245,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -257,7 +257,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         T QueryByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
             OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -270,7 +270,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
             OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -284,7 +284,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseTranLock">是否使用TranLock</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<T> QueryByClauseWithTranLockAsync(Expression<Func<T, bool>> predicate,
             Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseTranLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -706,16 +706,20 @@ namespace CoreCms.Net.IRepository
         /// </summary>
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false);
+        int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据总数
         /// </summary>
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false);
+        Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -723,8 +727,10 @@ namespace CoreCms.Net.IRepository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false);
+        int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -732,8 +738,10 @@ namespace CoreCms.Net.IRepository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        Task<int> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false);
+        Task<int> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -741,8 +749,10 @@ namespace CoreCms.Net.IRepository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        decimal GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false);
+        decimal GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -750,8 +760,10 @@ namespace CoreCms.Net.IRepository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        Task<decimal> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false);
+        Task<decimal> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -759,8 +771,10 @@ namespace CoreCms.Net.IRepository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        float GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false);
+        float GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -768,8 +782,10 @@ namespace CoreCms.Net.IRepository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        Task<float> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false);
+        Task<float> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
         #endregion
 
         #region 分页查询
@@ -783,7 +799,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="pageSize">分布大小</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         IPageList<T> QueryPage(Expression<Func<T, bool>> predicate, string orderBy = "", int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -796,7 +812,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="pageSize">分布大小</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate, string orderBy = "", int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -810,7 +826,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderByExpression"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         IPageList<T> QueryPage(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -824,7 +840,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="orderByExpression"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -843,7 +859,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         List<TResult> QueryMuch<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -861,7 +877,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         Task<List<TResult>> QueryMuchAsync<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -879,7 +895,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         TResult QueryMuchFirst<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -897,7 +913,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         Task<TResult> QueryMuchFirstAsync<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -916,7 +932,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         List<TResult> QueryMuch<T1, T2, T3, TResult>(
             Expression<Func<T1, T2, T3, object[]>> joinExpression,
@@ -935,7 +951,7 @@ namespace CoreCms.Net.IRepository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         Task<List<TResult>> QueryMuchAsync<T1, T2, T3, TResult>(
             Expression<Func<T1, T2, T3, object[]>> joinExpression,
@@ -960,7 +976,7 @@ namespace CoreCms.Net.IRepository
         /// <typeparam name="T"></typeparam>
         /// <param name="sql"></param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> SqlQueryable(string sql, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
diff --git a/CoreCms.Net.IServices/IBaseServices.cs b/CoreCms.Net.IServices/IBaseServices.cs
index 2a62a581..0493d945 100644
--- a/CoreCms.Net.IServices/IBaseServices.cs
+++ b/CoreCms.Net.IServices/IBaseServices.cs
@@ -33,7 +33,7 @@ namespace CoreCms.Net.IServices
         /// <param name="pkValue">主键值</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体</returns>
         T QueryById(object pkValue, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -43,7 +43,7 @@ namespace CoreCms.Net.IServices
         /// <param name="objId"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<T> QueryByIdAsync(object objId, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -53,7 +53,7 @@ namespace CoreCms.Net.IServices
         /// <param name="lstIds"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         List<T> QueryByIDs(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -63,7 +63,7 @@ namespace CoreCms.Net.IServices
         /// <param name="lstIds"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> QueryByIDsAsync(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -73,7 +73,7 @@ namespace CoreCms.Net.IServices
         /// <param name="lstIds"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         List<T> QueryByIDs(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -83,7 +83,7 @@ namespace CoreCms.Net.IServices
         /// <param name="lstIds"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> QueryByIDsAsync(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -92,7 +92,7 @@ namespace CoreCms.Net.IServices
         /// </summary>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         List<T> Query(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -101,7 +101,7 @@ namespace CoreCms.Net.IServices
         /// </summary>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> QueryAsync(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -112,7 +112,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderBy">排序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         List<T> QueryListByClause(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -123,7 +123,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderBy">排序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         Task<List<T>> QueryListByClauseAsync(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -134,7 +134,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderBy">排序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         List<T> QueryListByClause(Expression<Func<T, bool>> predicate, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -145,7 +145,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderBy">排序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, string orderBy = "",
             bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -158,7 +158,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         List<T> QueryListByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
             OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -171,7 +171,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate,
             Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -185,7 +185,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take,
             Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -199,7 +199,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take,
             Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -212,7 +212,7 @@ namespace CoreCms.Net.IServices
         /// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take, string strOrderByFields = "",
             bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -225,7 +225,7 @@ namespace CoreCms.Net.IServices
         /// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take,
             string strOrderByFields = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -236,7 +236,7 @@ namespace CoreCms.Net.IServices
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         T QueryByClause(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -246,7 +246,7 @@ namespace CoreCms.Net.IServices
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -258,7 +258,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         T QueryByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
             OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -271,7 +271,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate,
             OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -285,7 +285,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseTranLock">是否使用TranLock</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<T> QueryByClauseWithTranLockAsync(Expression<Func<T, bool>> predicate,
             Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseTranLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
@@ -707,16 +707,20 @@ namespace CoreCms.Net.IServices
         /// </summary>
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false);
+        int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据总数
         /// </summary>
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false);
+        Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -724,8 +728,10 @@ namespace CoreCms.Net.IServices
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false);
+        int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -733,8 +739,10 @@ namespace CoreCms.Net.IServices
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        Task<int> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false);
+        Task<int> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -742,8 +750,10 @@ namespace CoreCms.Net.IServices
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        decimal GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false);
+        decimal GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -751,8 +761,10 @@ namespace CoreCms.Net.IServices
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        Task<decimal> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false);
+        Task<decimal> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -760,8 +772,10 @@ namespace CoreCms.Net.IServices
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        float GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false);
+        float GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
         /// <summary>
         ///     获取数据某个字段的合计
@@ -769,8 +783,10 @@ namespace CoreCms.Net.IServices
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        Task<float> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false);
+        Task<float> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
         #endregion
 
         #region 分页查询
@@ -784,7 +800,7 @@ namespace CoreCms.Net.IServices
         /// <param name="pageSize">分布大小</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         IPageList<T> QueryPage(Expression<Func<T, bool>> predicate, string orderBy = "", int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -797,7 +813,7 @@ namespace CoreCms.Net.IServices
         /// <param name="pageSize">分布大小</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate, string orderBy = "", int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -811,7 +827,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderByExpression"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         IPageList<T> QueryPage(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -825,7 +841,7 @@ namespace CoreCms.Net.IServices
         /// <param name="orderByExpression"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
@@ -844,7 +860,7 @@ namespace CoreCms.Net.IServices
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         List<TResult> QueryMuch<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -862,7 +878,7 @@ namespace CoreCms.Net.IServices
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         Task<List<TResult>> QueryMuchAsync<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -880,7 +896,7 @@ namespace CoreCms.Net.IServices
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         TResult QueryMuchFirst<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -898,7 +914,7 @@ namespace CoreCms.Net.IServices
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         Task<TResult> QueryMuchFirstAsync<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -917,7 +933,7 @@ namespace CoreCms.Net.IServices
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         List<TResult> QueryMuch<T1, T2, T3, TResult>(
             Expression<Func<T1, T2, T3, object[]>> joinExpression,
@@ -936,7 +952,7 @@ namespace CoreCms.Net.IServices
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         Task<List<TResult>> QueryMuchAsync<T1, T2, T3, TResult>(
             Expression<Func<T1, T2, T3, object[]>> joinExpression,
@@ -961,7 +977,7 @@ namespace CoreCms.Net.IServices
         /// <typeparam name="T"></typeparam>
         /// <param name="sql"></param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         Task<List<T>> SqlQueryable(string sql, bool isDataCache = false, int cacheTimes = int.MaxValue);
 
diff --git a/CoreCms.Net.Repository/BaseRepository.cs b/CoreCms.Net.Repository/BaseRepository.cs
index 32f8119a..2139d2e2 100644
--- a/CoreCms.Net.Repository/BaseRepository.cs
+++ b/CoreCms.Net.Repository/BaseRepository.cs
@@ -43,7 +43,7 @@ namespace CoreCms.Net.Repository
         /// <param name="pkValue">主键值</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体</returns>
         public T QueryById(object pkValue, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -58,7 +58,7 @@ namespace CoreCms.Net.Repository
         /// <param name="objId">id（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>数据实体</returns>
         public async Task<T> QueryByIdAsync(object objId, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -74,7 +74,7 @@ namespace CoreCms.Net.Repository
         /// <returns>数据实体列表</returns>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         public List<T> QueryByIDs(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
@@ -89,7 +89,7 @@ namespace CoreCms.Net.Repository
         /// <returns>数据实体列表</returns>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         public async Task<List<T>> QueryByIDsAsync(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
@@ -104,7 +104,7 @@ namespace CoreCms.Net.Repository
         /// <returns>数据实体列表</returns>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         public List<T> QueryByIDs(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
@@ -119,7 +119,7 @@ namespace CoreCms.Net.Repository
         /// <returns>数据实体列表</returns>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         public async Task<List<T>> QueryByIDsAsync(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
@@ -132,7 +132,7 @@ namespace CoreCms.Net.Repository
         /// </summary>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public List<T> Query(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -146,7 +146,7 @@ namespace CoreCms.Net.Repository
         /// </summary>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<List<T>> QueryAsync(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -162,7 +162,7 @@ namespace CoreCms.Net.Repository
         /// <param name="orderBy">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         public List<T> QueryListByClause(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -188,7 +188,7 @@ namespace CoreCms.Net.Repository
         /// <returns>泛型实体集合</returns>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         public async Task<List<T>> QueryListByClauseAsync(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
@@ -213,7 +213,7 @@ namespace CoreCms.Net.Repository
         /// <returns>泛型实体集合</returns>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         public List<T> QueryListByClause(Expression<Func<T, bool>> predicate, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
@@ -238,7 +238,7 @@ namespace CoreCms.Net.Repository
         /// <returns>泛型实体集合</returns>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         public async Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
@@ -263,7 +263,7 @@ namespace CoreCms.Net.Repository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         public List<T> QueryListByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -289,7 +289,7 @@ namespace CoreCms.Net.Repository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         public async Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -316,7 +316,7 @@ namespace CoreCms.Net.Repository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -345,7 +345,7 @@ namespace CoreCms.Net.Repository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -373,7 +373,7 @@ namespace CoreCms.Net.Repository
         /// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take, string strOrderByFields = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -401,7 +401,7 @@ namespace CoreCms.Net.Repository
         /// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take, string strOrderByFields = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -427,7 +427,7 @@ namespace CoreCms.Net.Repository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public T QueryByClause(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -447,7 +447,7 @@ namespace CoreCms.Net.Repository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -469,7 +469,7 @@ namespace CoreCms.Net.Repository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public T QueryByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -486,7 +486,7 @@ namespace CoreCms.Net.Repository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -504,7 +504,7 @@ namespace CoreCms.Net.Repository
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseTranLock">是否使用TranLock</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<T> QueryByClauseWithTranLockAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseTranLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -1146,17 +1146,20 @@ namespace CoreCms.Net.Repository
         #endregion
 
         #region 统计数据
+
         /// <summary>
         ///     获取数据总数
         /// </summary>
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        public int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false)
+        public int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
-                ? DbBaseClient.Queryable<T>().With(SqlWith.NoLock).Count(predicate)
-                : DbBaseClient.Queryable<T>().Count(predicate);
+                ? DbBaseClient.Queryable<T>().With(SqlWith.NoLock).WithCacheIF(isDataCache, cacheTimes).Count(predicate)
+                : DbBaseClient.Queryable<T>().WithCacheIF(isDataCache, cacheTimes).Count(predicate);
         }
 
         /// <summary>
@@ -1164,12 +1167,14 @@ namespace CoreCms.Net.Repository
         /// </summary>
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        public async Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false)
+        public async Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
-                ? await DbBaseClient.Queryable<T>().With(SqlWith.NoLock).CountAsync(predicate)
-                : await DbBaseClient.Queryable<T>().CountAsync(predicate);
+                ? await DbBaseClient.Queryable<T>().With(SqlWith.NoLock).WithCacheIF(isDataCache, cacheTimes).CountAsync(predicate)
+                : await DbBaseClient.Queryable<T>().WithCacheIF(isDataCache, cacheTimes).CountAsync(predicate);
         }
 
         /// <summary>
@@ -1178,12 +1183,14 @@ namespace CoreCms.Net.Repository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        public int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false)
+        public int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
-                ? DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).Sum(field)
-                : DbBaseClient.Queryable<T>().Where(predicate).Sum(field);
+                ? DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).WithCacheIF(isDataCache, cacheTimes).Sum(field)
+                : DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).Sum(field);
         }
 
         /// <summary>
@@ -1192,13 +1199,15 @@ namespace CoreCms.Net.Repository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<int> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field,
-            bool blUseNoLock = false)
+            bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
-                ? await DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).SumAsync(field)
-                : await DbBaseClient.Queryable<T>().Where(predicate).SumAsync(field);
+                ? await DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).WithCacheIF(isDataCache, cacheTimes).SumAsync(field)
+                : await DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).SumAsync(field);
         }
 
         /// <summary>
@@ -1207,13 +1216,15 @@ namespace CoreCms.Net.Repository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public decimal GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field,
-            bool blUseNoLock = false)
+            bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
-                ? DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).Sum(field)
-                : DbBaseClient.Queryable<T>().Where(predicate).Sum(field);
+                ? DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).WithCacheIF(isDataCache, cacheTimes).Sum(field)
+                : DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).Sum(field);
         }
 
         /// <summary>
@@ -1222,13 +1233,15 @@ namespace CoreCms.Net.Repository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<decimal> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field,
-            bool blUseNoLock = false)
+            bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
-                ? await DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).SumAsync(field)
-                : await DbBaseClient.Queryable<T>().Where(predicate).SumAsync(field);
+                ? await DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).WithCacheIF(isDataCache, cacheTimes).SumAsync(field)
+                : await DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).SumAsync(field);
         }
 
         /// <summary>
@@ -1237,13 +1250,15 @@ namespace CoreCms.Net.Repository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public float GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field,
-            bool blUseNoLock = false)
+            bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
-                ? DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).Sum(field)
-                : DbBaseClient.Queryable<T>().Where(predicate).Sum(field);
+                ? DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).WithCacheIF(isDataCache, cacheTimes).Sum(field)
+                : DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).Sum(field);
         }
 
         /// <summary>
@@ -1252,13 +1267,15 @@ namespace CoreCms.Net.Repository
         /// <param name="predicate">条件表达式树</param>
         /// <param name="field">字段</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<float> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field,
-            bool blUseNoLock = false)
+            bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
             return blUseNoLock
-                ? await DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).SumAsync(field)
-                : await DbBaseClient.Queryable<T>().Where(predicate).SumAsync(field);
+                ? await DbBaseClient.Queryable<T>().Where(predicate).With(SqlWith.NoLock).WithCacheIF(isDataCache, cacheTimes).SumAsync(field)
+                : await DbBaseClient.Queryable<T>().Where(predicate).WithCacheIF(isDataCache, cacheTimes).SumAsync(field);
         }
         #endregion
 
@@ -1273,7 +1290,7 @@ namespace CoreCms.Net.Repository
         /// <param name="pageSize">分布大小</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public IPageList<T> QueryPage(Expression<Func<T, bool>> predicate, string orderBy = "", int pageIndex = 1,
             int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
@@ -1306,7 +1323,7 @@ namespace CoreCms.Net.Repository
         /// <param name="pageSize">分布大小</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate, string orderBy = "",
             int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
@@ -1338,7 +1355,7 @@ namespace CoreCms.Net.Repository
         /// <param name="orderByExpression"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public IPageList<T> QueryPage(Expression<Func<T, bool>> predicate,
             Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1,
@@ -1371,7 +1388,7 @@ namespace CoreCms.Net.Repository
         /// <param name="orderByExpression"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate,
             Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1,
@@ -1408,7 +1425,7 @@ namespace CoreCms.Net.Repository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public List<TResult> QueryMuch<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -1436,7 +1453,7 @@ namespace CoreCms.Net.Repository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public async Task<List<TResult>> QueryMuchAsync<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -1464,7 +1481,7 @@ namespace CoreCms.Net.Repository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public TResult QueryMuchFirst<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -1492,7 +1509,7 @@ namespace CoreCms.Net.Repository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public async Task<TResult> QueryMuchFirstAsync<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -1521,7 +1538,7 @@ namespace CoreCms.Net.Repository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public List<TResult> QueryMuch<T1, T2, T3, TResult>(
             Expression<Func<T1, T2, T3, object[]>> joinExpression,
@@ -1550,7 +1567,7 @@ namespace CoreCms.Net.Repository
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public async Task<List<TResult>> QueryMuchAsync<T1, T2, T3, TResult>(
             Expression<Func<T1, T2, T3, object[]>> joinExpression,
@@ -1589,7 +1606,7 @@ namespace CoreCms.Net.Repository
         /// <typeparam name="T"></typeparam>
         /// <param name="sql"></param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<List<T>> SqlQueryable(string sql, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
diff --git a/CoreCms.Net.Services/BaseServices.cs b/CoreCms.Net.Services/BaseServices.cs
index e3f8dfba..d1b33d52 100644
--- a/CoreCms.Net.Services/BaseServices.cs
+++ b/CoreCms.Net.Services/BaseServices.cs
@@ -33,7 +33,7 @@ namespace CoreCms.Net.Services
         /// <param name="pkValue">主键值</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体</returns>
         public T QueryById(object pkValue, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -46,7 +46,7 @@ namespace CoreCms.Net.Services
         /// <param name="objId">id（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>数据实体</returns>
         public async Task<T> QueryByIdAsync(object objId, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -59,7 +59,7 @@ namespace CoreCms.Net.Services
         /// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>数据实体列表</returns>
         public List<T> QueryByIDs(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -72,7 +72,7 @@ namespace CoreCms.Net.Services
         /// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>数据实体列表</returns>
         public async Task<List<T>> QueryByIDsAsync(object[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -85,7 +85,7 @@ namespace CoreCms.Net.Services
         /// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>数据实体列表</returns>
         public List<T> QueryByIDs(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -98,7 +98,7 @@ namespace CoreCms.Net.Services
         /// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>数据实体列表</returns>
         public async Task<List<T>> QueryByIDsAsync(int[] lstIds, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -110,7 +110,7 @@ namespace CoreCms.Net.Services
         /// </summary>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public List<T> Query(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -123,7 +123,7 @@ namespace CoreCms.Net.Services
         /// </summary>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<List<T>> QueryAsync(bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -137,7 +137,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderBy">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         public List<T> QueryListByClause(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -151,7 +151,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderBy">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         public async Task<List<T>> QueryListByClauseAsync(string strWhere, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -165,7 +165,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderBy">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         public List<T> QueryListByClause(Expression<Func<T, bool>> predicate, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -179,7 +179,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderBy">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         public async Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, string orderBy = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -194,7 +194,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         public List<T> QueryListByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -209,7 +209,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>泛型实体集合</returns>
         public async Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -225,7 +225,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -241,7 +241,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -256,7 +256,7 @@ namespace CoreCms.Net.Services
         /// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public List<T> QueryListByClause(Expression<Func<T, bool>> predicate, int take, string strOrderByFields = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -271,7 +271,7 @@ namespace CoreCms.Net.Services
         /// <param name="strOrderByFields">排序字段，如name asc,age desc</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<List<T>> QueryListByClauseAsync(Expression<Func<T, bool>> predicate, int take, string strOrderByFields = "", bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -284,7 +284,7 @@ namespace CoreCms.Net.Services
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public T QueryByClause(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -297,7 +297,7 @@ namespace CoreCms.Net.Services
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -312,7 +312,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public T QueryByClause(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -328,7 +328,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<T> QueryByClauseAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -344,7 +344,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderByType">排序顺序</param>
         /// <param name="blUseTranLock">是否使用TranLock</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<T> QueryByClauseWithTranLockAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, object>> orderByPredicate, OrderByType orderByType, bool blUseTranLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
@@ -898,15 +898,18 @@ namespace CoreCms.Net.Services
         #endregion
 
         #region 统计数据
+
         /// <summary>
         ///     获取数据总数
         /// </summary>
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        public int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false)
+        public int GetCount(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
-            return BaseDal.GetCount(predicate, blUseNoLock);
+            return BaseDal.GetCount(predicate, blUseNoLock, isDataCache, cacheTimes);
         }
 
         /// <summary>
@@ -914,10 +917,12 @@ namespace CoreCms.Net.Services
         /// </summary>
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        public async Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false)
+        public async Task<int> GetCountAsync(Expression<Func<T, bool>> predicate, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
-            return await BaseDal.GetCountAsync(predicate, blUseNoLock);
+            return await BaseDal.GetCountAsync(predicate, blUseNoLock, isDataCache, cacheTimes);
         }
 
         /// <summary>
@@ -926,10 +931,12 @@ namespace CoreCms.Net.Services
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="field">字段</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
-        public int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false)
+        public int GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
-            return BaseDal.GetSum(predicate, field, blUseNoLock);
+            return BaseDal.GetSum(predicate, field, blUseNoLock, isDataCache, cacheTimes);
         }
 
         /// <summary>
@@ -938,11 +945,13 @@ namespace CoreCms.Net.Services
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="field">字段</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<int> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, int>> field,
-            bool blUseNoLock = false)
+            bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
-            return await BaseDal.GetSumAsync(predicate, field, blUseNoLock);
+            return await BaseDal.GetSumAsync(predicate, field, blUseNoLock, isDataCache, cacheTimes);
         }
 
         /// <summary>
@@ -951,11 +960,13 @@ namespace CoreCms.Net.Services
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="field">字段</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public decimal GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field,
-            bool blUseNoLock = false)
+            bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
-            return BaseDal.GetSum(predicate, field, blUseNoLock);
+            return BaseDal.GetSum(predicate, field, blUseNoLock, isDataCache, cacheTimes);
         }
 
         /// <summary>
@@ -964,11 +975,13 @@ namespace CoreCms.Net.Services
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="field">字段</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<decimal> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, decimal>> field,
-            bool blUseNoLock = false)
+            bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
-            return await BaseDal.GetSumAsync(predicate, field, blUseNoLock);
+            return await BaseDal.GetSumAsync(predicate, field, blUseNoLock, isDataCache, cacheTimes);
         }
 
         /// <summary>
@@ -977,11 +990,13 @@ namespace CoreCms.Net.Services
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="field">字段</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public float GetSum(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field,
-            bool blUseNoLock = false)
+            bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
-            return BaseDal.GetSum(predicate, field, blUseNoLock);
+            return BaseDal.GetSum(predicate, field, blUseNoLock, isDataCache, cacheTimes);
         }
 
         /// <summary>
@@ -990,11 +1005,13 @@ namespace CoreCms.Net.Services
         /// <param name="predicate">条件表达式树</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="field">字段</param>
+        /// <param name="isDataCache">是否缓存</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<float> GetSumAsync(Expression<Func<T, bool>> predicate, Expression<Func<T, float>> field,
-            bool blUseNoLock = false)
+            bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {
-            return await BaseDal.GetSumAsync(predicate, field, blUseNoLock);
+            return await BaseDal.GetSumAsync(predicate, field, blUseNoLock, isDataCache, cacheTimes);
         }
         #endregion
 
@@ -1009,7 +1026,7 @@ namespace CoreCms.Net.Services
         /// <param name="pageSize">分布大小</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public IPageList<T> QueryPage(Expression<Func<T, bool>> predicate, string orderBy = "", int pageIndex = 1,
             int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
@@ -1026,7 +1043,7 @@ namespace CoreCms.Net.Services
         /// <param name="pageSize">分布大小</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate, string orderBy = "",
             int pageIndex = 1, int pageSize = 20, bool blUseNoLock = false, bool isDataCache = false, int cacheTimes = int.MaxValue)
@@ -1044,7 +1061,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderByExpression"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public IPageList<T> QueryPage(Expression<Func<T, bool>> predicate,
             Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1,
@@ -1063,7 +1080,7 @@ namespace CoreCms.Net.Services
         /// <param name="orderByExpression"></param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<IPageList<T>> QueryPageAsync(Expression<Func<T, bool>> predicate,
             Expression<Func<T, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1,
@@ -1086,7 +1103,7 @@ namespace CoreCms.Net.Services
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public List<TResult> QueryMuch<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -1107,7 +1124,7 @@ namespace CoreCms.Net.Services
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public async Task<List<TResult>> QueryMuchAsync<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -1128,7 +1145,7 @@ namespace CoreCms.Net.Services
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public TResult QueryMuchFirst<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -1149,7 +1166,7 @@ namespace CoreCms.Net.Services
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public async Task<TResult> QueryMuchFirstAsync<T1, T2, TResult>(
             Expression<Func<T1, T2, object[]>> joinExpression,
@@ -1171,7 +1188,7 @@ namespace CoreCms.Net.Services
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public List<TResult> QueryMuch<T1, T2, T3, TResult>(
             Expression<Func<T1, T2, T3, object[]>> joinExpression,
@@ -1193,7 +1210,7 @@ namespace CoreCms.Net.Services
         /// <param name="whereLambda">查询表达式 (w1, w2) =>w1.UserNo == "")</param>
         /// <param name="blUseNoLock">是否使用WITH(NoLock)</param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns>值</returns>
         public async Task<List<TResult>> QueryMuchAsync<T1, T2, T3, TResult>(
             Expression<Func<T1, T2, T3, object[]>> joinExpression,
@@ -1224,7 +1241,7 @@ namespace CoreCms.Net.Services
         /// <typeparam name="T"></typeparam>
         /// <param name="sql"></param>
         /// <param name="isDataCache">是否启用缓存</param>
-        /// <param name="cacheTimes">缓存时长（秒）</param>
+        /// <param name="cacheTimes">缓存时长（分钟）</param>
         /// <returns></returns>
         public async Task<List<T>> SqlQueryable(string sql, bool isDataCache = false, int cacheTimes = int.MaxValue)
         {