使用SqlSugar封装的数据层基类

首先简单封装了个DbContext

  public class DbContext
     {
         #region 属性字段
         private static string _connectionString;

         /// <summary>
         /// 连接字符串 by beck.huang 2018-05-08 09:56:05
         /// </summary>
         public static string ConnectionString
         {
             get { return _connectionString; }
             set { _connectionString = value; }
         }

         private static DbType _dbType;

         /// <summary>
         /// 数据库类型 by beck.huang 2018-05-08 09:58:03
         /// </summary>
         public static DbType DbType
         {
             get { return _dbType; }
             set { _dbType = value; }
         }

         private SqlSugarClient _db;

         /// <summary>
         /// 数据连接对象 by beck.huang 2018-05-08 10:00:14
         /// </summary>
         public SqlSugarClient Db
         {
             get { return _db; }
             private set { _db = value; }
         }

         /// <summary>
         /// 数据库上下文实例（自动关闭连接） by beck.huang 2018-05-08 09:47:30
         /// </summary>
         public static DbContext Context
         {
             get
             {
                 return new DbContext();
             }

         }
         #endregion

         #region 构造函数

         /// <summary>
         /// 功能描述:构造函数
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-08 09:47:24
         /// 任务编号:中餐
         /// </summary>
         private DbContext()
         {
             if (string.IsNullOrEmpty(_connectionString))
                 throw new ArgumentNullException("数据库连接字符串为空");
             _db = new SqlSugarClient(new ConnectionConfig()
             {
                 ConnectionString = _connectionString,
                 DbType = _dbType,
                 IsAutoCloseConnection = true,
                 IsShardSameThread = true,
                 ConfigureExternalServices = new ConfigureExternalServices()
                 {
                     DataInfoCacheService = new HttpRuntimeCache()
                 },
                 MoreSettings = new ConnMoreSettings()
                 {
                     //IsWithNoLockQuery = true,
                     IsAutoRemoveDataCache = true
                 }
             });
         }

         /// <summary>
         /// 功能描述:构造函数
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-28 17:23:19
         /// 任务编号:中餐
         /// </summary>
         /// <param name="blnIsAutoCloseConnection">是否自动关闭连接</param>
         private DbContext(bool blnIsAutoCloseConnection)
         {
             if (string.IsNullOrEmpty(_connectionString))
                 throw new ArgumentNullException("数据库连接字符串为空");
             _db = new SqlSugarClient(new ConnectionConfig()
             {
                 ConnectionString = _connectionString,
                 DbType = _dbType,
                 IsAutoCloseConnection = blnIsAutoCloseConnection,
                 IsShardSameThread = true,
                 ConfigureExternalServices = new ConfigureExternalServices()
                 {
                     DataInfoCacheService = new HttpRuntimeCache()
                 },
                 MoreSettings = new ConnMoreSettings()
                 {
                     //IsWithNoLockQuery = true,
                     IsAutoRemoveDataCache = true
                 }
             });
         }
         #endregion

         #region 实例方法
         /// <summary>
         /// 功能描述:获取数据库处理对象
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-08 09:46:06
         /// 任务编号:中餐
         /// </summary>
         /// <returns>返回值</returns>
         public SimpleClient<T> GetEntityDB<T>() where T : class,new()
         {
             return new SimpleClient<T>(_db);
         }
         /// <summary>
         /// 功能描述:获取数据库处理对象
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-09 09:17:43
         /// 任务编号:中餐
         /// </summary>
         /// <param name="db">db</param>
         /// <returns>返回值</returns>
         public SimpleClient<T> GetEntityDB<T>(SqlSugarClient db) where T : class,new()
         {
             return new SimpleClient<T>(db);
         }

         #region 根据数据库表生产实体类
         /// <summary>
         /// 功能描述:根据数据库表生产实体类
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-08 10:14:37
         /// 任务编号:中餐
         /// </summary>
         /// <param name="strPath">实体类存放路径</param>
         public void CreateClassFileByDBTalbe(string strPath)
         {
             CreateClassFileByDBTalbe(strPath, "Km.PosZC");
         }
         /// <summary>
         /// 功能描述:根据数据库表生产实体类
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-08 10:10:59
         /// 任务编号:中餐
         /// </summary>
         /// <param name="strPath">实体类存放路径</param>
         /// <param name="strNameSpace">命名空间</param>
         public void CreateClassFileByDBTalbe(string strPath, string strNameSpace)
         {
             CreateClassFileByDBTalbe(strPath, strNameSpace, null);
         }

         /// <summary>
         /// 功能描述:根据数据库表生产实体类
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-08 10:18:18
         /// 任务编号:中餐
         /// </summary>
         /// <param name="strPath">实体类存放路径</param>
         /// <param name="strNameSpace">命名空间</param>
         /// <param name="lstTableNames">生产指定的表</param>
         public void CreateClassFileByDBTalbe(
             string strPath,
             string strNameSpace,
             string[] lstTableNames)
         {
             CreateClassFileByDBTalbe(strPath, strNameSpace, lstTableNames, string.Empty);
         }

         /// <summary>
         /// 功能描述:根据数据库表生产实体类
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-09 15:38:22
         /// 任务编号:中餐
         /// </summary>
         /// <param name="strPath">实体类存放路径</param>
         /// <param name="strNameSpace">命名空间</param>
         /// <param name="lstTableNames">生产指定的表</param>
         /// <param name="strInterface">实现接口</param>
         public void CreateClassFileByDBTalbe(
           string strPath,
           string strNameSpace,
           string[] lstTableNames,
           string strInterface,
           bool blnSerializable = false)
         {
             if (lstTableNames != null && lstTableNames.Length > )
             {
                 _db.DbFirst.Where(lstTableNames).IsCreateDefaultValue().IsCreateAttribute()
                     .SettingClassTemplate(p => p = @"
 {using}

 namespace {Namespace}
 {
     {ClassDescription}{SugarTable}" + (blnSerializable ? "[Serializable]" : "") + @"
     public partial class {ClassName}" + (string.IsNullOrEmpty(strInterface) ? "" : (" : " + strInterface)) + @"
     {
         public {ClassName}()
         {
 {Constructor}
         }
 {PropertyName}
     }
 }
 ")
                     .SettingPropertyTemplate(p => p = @"
             {SugarColumn}
             public {PropertyType} {PropertyName}
             {
                 get
                 {
                     return _{PropertyName};
                 }
                 set
                 {
                     if(_{PropertyName}!=value)
                     {
                         base.SetValueCall(" + "\"{PropertyName}\",_{PropertyName}" + @");
                     }
                     _{PropertyName}=value;
                 }
             }")
                     .SettingPropertyDescriptionTemplate(p => p = "          private {PropertyType} _{PropertyName};\r\n" + p)
                     .SettingConstructorTemplate(p => p = "              this._{PropertyName} ={DefaultValue};")
                     .CreateClassFile(strPath, strNameSpace);
             }
             else
             {
                 _db.DbFirst.IsCreateAttribute().IsCreateDefaultValue()
                     .SettingClassTemplate(p => p = @"
 {using}

 namespace {Namespace}
 {
     {ClassDescription}{SugarTable}" + (blnSerializable ? "[Serializable]" : "") + @"
     public partial class {ClassName}" + (string.IsNullOrEmpty(strInterface) ? "" : (" : " + strInterface)) + @"
     {
         public {ClassName}()
         {
 {Constructor}
         }
 {PropertyName}
     }
 }
 ")
                     .SettingPropertyTemplate(p => p = @"
             {SugarColumn}
             public {PropertyType} {PropertyName}
             {
                 get
                 {
                     return _{PropertyName};
                 }
                 set
                 {
                     if(_{PropertyName}!=value)
                     {
                         base.SetValueCall(" + "\"{PropertyName}\",_{PropertyName}" + @");
                     }
                     _{PropertyName}=value;
                 }
             }")
                     .SettingPropertyDescriptionTemplate(p => p = "          private {PropertyType} _{PropertyName};\r\n" + p)
                     .SettingConstructorTemplate(p => p = "              this._{PropertyName} ={DefaultValue};")
                     .CreateClassFile(strPath, strNameSpace);
             }
         }
         #endregion

         #region 根据实体类生成数据库表
         /// <summary>
         /// 功能描述:根据实体类生成数据库表
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-08 10:31:02
         /// 任务编号:中餐
         /// </summary>
         /// <param name="blnBackupTable">是否备份表</param>
         /// <param name="lstEntitys">指定的实体</param>
         public void CreateTableByEntity<T>(bool blnBackupTable, params T[] lstEntitys) where T : class,new()
         {
             Type[] lstTypes = null;
             if (lstEntitys != null)
             {
                 lstTypes = new Type[lstEntitys.Length];
                 for (int i = ; i < lstEntitys.Length; i++)
                 {
                     T t = lstEntitys[i];
                     lstTypes[i] = typeof(T);
                 }
             }
             CreateTableByEntity(blnBackupTable, lstTypes);
         }

         /// <summary>
         /// 功能描述:根据实体类生成数据库表
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-08 10:31:14
         /// 任务编号:中餐
         /// </summary>
         /// <param name="blnBackupTable">是否备份表</param>
         /// <param name="lstEntitys">指定的实体</param>
         public void CreateTableByEntity(bool blnBackupTable, params Type[] lstEntitys)
         {
             if (blnBackupTable)
             {
                 _db.CodeFirst.BackupTable().InitTables(lstEntitys); //change entity backupTable
             }
             else
             {
                 _db.CodeFirst.InitTables(lstEntitys);
             }
         }
         #endregion

         #endregion

         #region 静态方法

         /// <summary>
         /// 功能描述:获得一个DbContext
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-28 17:24:12
         /// 任务编号:中餐
         /// </summary>
         /// <param name="blnIsAutoCloseConnection">是否自动关闭连接（如果为false，则使用接受时需要手动关闭Db）</param>
         /// <returns>返回值</returns>
         public static DbContext GetDbContext(bool blnIsAutoCloseConnection)
         {
             return new DbContext(blnIsAutoCloseConnection);
         }

         /// <summary>
         /// 功能描述:设置初始化参数
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-08 10:02:32
         /// 任务编号:中餐
         /// </summary>
         /// <param name="strConnectionString">连接字符串</param>
         /// <param name="enmDbType">数据库类型</param>
         public static void Init(string strConnectionString, DbType enmDbType = SqlSugar.DbType.MySql)
         {
             _connectionString = strConnectionString;
             _dbType = enmDbType;
         }

         /// <summary>
         /// 功能描述:创建一个链接配置
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-09 09:03:33
         /// 任务编号:中餐
         /// </summary>
         /// <param name="blnIsAutoCloseConnection">是否自动关闭连接</param>
         /// <param name="blnIsShardSameThread">是否夸类事务</param>
         /// <returns>ConnectionConfig</returns>
         public static ConnectionConfig GetConnectionConfig(bool blnIsAutoCloseConnection = true, bool blnIsShardSameThread = false)
         {
             ConnectionConfig config = new ConnectionConfig()
             {
                 ConnectionString = _connectionString,
                 DbType = _dbType,
                 IsAutoCloseConnection = blnIsAutoCloseConnection,
                 ConfigureExternalServices = new ConfigureExternalServices()
                 {
                     DataInfoCacheService = new HttpRuntimeCache()
                 },
                 IsShardSameThread = blnIsShardSameThread
             };
             return config;
         }

         /// <summary>
         /// 功能描述:获取一个自定义的DB
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-08 09:49:36
         /// 任务编号:中餐
         /// </summary>
         /// <param name="config">config</param>
         /// <returns>返回值</returns>
         public static SqlSugarClient GetCustomDB(ConnectionConfig config)
         {
             return new SqlSugarClient(config);
         }
         /// <summary>
         /// 功能描述:获取一个自定义的数据库处理对象
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-09 08:56:20
         /// 任务编号:中餐
         /// </summary>
         /// <param name="sugarClient">sugarClient</param>
         /// <returns>返回值</returns>
         public static SimpleClient<T> GetCustomEntityDB<T>(SqlSugarClient sugarClient) where T : class,new()
         {
             return new SimpleClient<T>(sugarClient);
         }
         /// <summary>
         /// 功能描述:获取一个自定义的数据库处理对象
         /// 作　　者:beck.huang
         /// 创建日期:2018-05-08 09:50:32
         /// 任务编号:中餐
         /// </summary>
         /// <param name="config">config</param>
         /// <returns>返回值</returns>
         public static SimpleClient<T> GetCustomEntityDB<T>(ConnectionConfig config) where T : class,new()
         {
             SqlSugarClient sugarClient = GetCustomDB(config);
             return GetCustomEntityDB<T>(sugarClient);
         }
         #endregion
     }

然后是一个BaseDal，基本上覆盖了大部分的增删改查功能

 public class BaseDal<T> where T : class ,new()
    {
        #region 属性字段
        private DbContext _context;

        public DbContext Context
        {
            get { return _context; }
            set { _context = value; }
        }

        private SqlSugarClient _db;

        /// <summary>
        /// 数据处理对象 by beck.huang 2018-05-09 09:31:24
        /// </summary>
        internal SqlSugarClient Db
        {
            get { return _db; }
            private set { _db = value; }
        }

        private SimpleClient<T> _entityDB;

        /// <summary>
        /// 实体数据处理对象 by beck.huang 2018-05-09 09:31:15
        /// </summary>
        internal SimpleClient<T> EntityDB
        {
            get { return _entityDB; }
            private set { _entityDB = value; }
        }

        public Action<Exception> OnDalError { get; set; }
        public Action<string, SugarParameter[]> OnDalLogExecuting { get; set; }
        public Action<string, SugarParameter[]> OnDalLogExecuted { get; set; }
        public Func<string, SugarParameter[], KeyValuePair<string, SugarParameter[]>> OnDalExecutingChangeSql { get; set; }
        #endregion

        #region 构造函数
        /// <summary>
        /// 功能描述:构造函数
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 09:30:54
        /// 任务编号:中餐
        /// </summary>
        /// <param name="blnIsAutoCloseConnection">是否自动关闭连接</param>
        public BaseDal(bool blnIsAutoCloseConnection = true)
        {
            DbContext context = DbContext.GetDbContext(blnIsAutoCloseConnection);
            _context = context;
            _db = context.Db;
            //_db.Aop.OnLogExecuted = new Action<string, SugarParameter[]>(OnLogExecuted);
            //_db.Aop.OnLogExecuting = OnDalLogExecuting;
            //_db.Aop.OnError = OnDalError;
            //_db.Aop.OnExecutingChangeSql = new Func<string, SugarParameter[], KeyValuePair<string, SugarParameter[]>>(OnExecutingChangeSql);
            _entityDB = context.GetEntityDB<T>(_db);
        }

        /// <summary>
        /// 功能描述:使用指定的DbContext初始化一个对象
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-28 17:31:57
        /// 任务编号:中餐
        /// </summary>
        /// <param name="context">DbContext</param>
        public BaseDal(DbContext context)
        {
            _context = context;
            _db = context.Db;
            _entityDB = context.GetEntityDB<T>(_db);
        }
        #endregion

        #region 增

        /// <summary>
        /// 功能描述:插入数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-16 17:57:26
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strSql">strSql</param>
        /// <param name="parameters">parameters</param>
        /// <returns>是否成功</returns>
        public bool Insert(string strSql, SugarParameter[] parameters = null)
        {
            return _db.Ado.ExecuteCommand(strSql, parameters) > ;
        }
        /// <summary>
        /// 功能描述:插入数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 09:43:06
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entitys">实体列表</param>
        /// <returns>是否成功</returns>
        public bool Insert(params T[] entitys)
        {
            if (entitys != null && entitys.Length > )
            {
                return _entityDB.InsertRange(entitys);
            }
            return true;
        }

        /// <summary>
        /// 功能描述:插入数据，返回自增列
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 09:44:52
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns>自增ID</returns>
        public int InsertReturnIdentity(T entity)
        {
            return _entityDB.InsertReturnIdentity(entity);
        }
        #endregion

        #region 删
        /// <summary>
        /// 功能描述:删除指定实体
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 09:47:38
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entity">实体（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>是否成功</returns>
        public bool Delete(T entity)
        {
            return _entityDB.Delete(entity);
        }

        /// <summary>
        /// 功能描述:删除数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:06:10
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entitys">实体列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>受影响行数</returns>
        public int Delete(T[] entitys)
        {
            if (entitys != null)
                return _db.Deleteable<T>(entitys.ToList()).ExecuteCommand();
            else
                return ;
        }
        /// <summary>
        /// 功能描述:删除数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 09:52:35
        /// 任务编号:中餐
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <returns>是否成功</returns>
        public bool Delete(Expression<Func<T, bool>> whereExpression)
        {
            return _entityDB.Delete(whereExpression);
        }
        /// <summary>
        /// 功能描述:删除数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:02:37
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <returns>是否成功</returns>
        public bool Delete(string strWhere)
        {
            return _db.Deleteable<T>().Where(strWhere).ExecuteCommand() > ;
        }
        /// <summary>
        /// 功能描述:删除数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:02:37
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="lstParameters">参数</param>
        /// <returns>是否成功</returns>
        public bool Delete(string strWhere, List<SugarParameter> lstParameters)
        {
            return _db.Deleteable<T>().Where(strWhere, lstParameters).ExecuteCommand() > ;
        }

        /// <summary>
        /// 功能描述:根据ID删除
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:08:18
        /// 任务编号:中餐
        /// </summary>
        /// <param name="ids">主键列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>受影响行数</returns>
        public int DeleteByID(params object[] ids)
        {
            return _db.Deleteable<T>().In(ids).ExecuteCommand();
        }

        #endregion

        #region 改

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-16 17:57:26
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strSql">strSql</param>
        /// <param name="parameters">parameters</param>
        /// <returns>是否成功</returns>
        public bool Update(string strSql, SugarParameter[] parameters = null)
        {
            return _db.Ado.ExecuteCommand(strSql, parameters) > ;
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:28:27
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entity">实体（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>是否成功</returns>
        public bool Update(T entity)
        {
            return _entityDB.Update(entity);
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:28:27
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="entity">条件</param>
        /// <returns>是否成功</returns>
        public bool Update(T entity, string strWhere)
        {
            return _db.Updateable(entity).Where(strWhere).ExecuteCommand() > ;
        }
        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:28:27
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="entity">条件</param>
        /// <param name="lstParameters">参数</param>
        /// <returns>是否成功</returns>
        public bool Update(
            T entity,
            string strWhere,
            List<SugarParameter> lstParameters)
        {
            return _db.Updateable(entity).Where(strWhere, lstParameters).ExecuteCommand() > ;
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:31:15
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entitys">实体列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>受影响行数</returns>
        public int Update(T[] entitys)
        {
            return Update(entitys, null, null);
        }
        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-16 15:31:09
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entitys">实体列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <returns>受影响行数</returns>
        public int Update(
            T[] entitys,
            List<string> lstColumns,
            List<string> lstIgnoreColumns)
        {
            return Update(entitys, lstColumns, lstIgnoreColumns, "");
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-16 15:31:47
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entitys">实体列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="strWhere">条件</param>
        /// <returns>受影响行数</returns>
        public int Update(
            T[] entitys,
            List<string> lstColumns,
            List<string> lstIgnoreColumns,
            string strWhere)
        {
            return Update(entitys, lstColumns, lstIgnoreColumns, strWhere, null);
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-16 15:33:06
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entitys">实体列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="strWhere">条件</param>
        /// <param name="lstParameters">条件参数</param>
        /// <returns>受影响行数</returns>
        public int Update(
            T[] entitys,
            List<string> lstColumns,
            List<string> lstIgnoreColumns,
            string strWhere,
            List<SugarParameter> lstParameters)
        {
            IUpdateable<T> up = _db.Updateable(entitys);
            if (lstIgnoreColumns != null && lstIgnoreColumns.Count > )
            {
                up = up.IgnoreColumns(it => lstIgnoreColumns.Contains(it));
            }
            if (lstColumns != null && lstColumns.Count > )
            {
                up = up.UpdateColumns(it => lstColumns.Contains(it));
            }
            if (!string.IsNullOrEmpty(strWhere))
            {
                up = up.Where(strWhere, lstParameters);
            }
            return up.ExecuteCommand();
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-16 15:33:36
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entitys">实体列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="whereExpression">条件</param>
        /// <returns>受影响行数</returns>
        public int Update(
            T[] entitys,
            List<string> lstColumns,
            List<string> lstIgnoreColumns,
            Expression<Func<T, bool>> whereExpression)
        {
            IUpdateable<T> up = _db.Updateable(entitys);
            if (lstIgnoreColumns != null && lstIgnoreColumns.Count > )
            {
                up = up.IgnoreColumns(it => lstIgnoreColumns.Contains(it));
            }
            if (lstColumns != null && lstColumns.Count > )
            {
                up = up.UpdateColumns(it => lstColumns.Contains(it));
            }
            if (whereExpression != null)
            {
                up = up.Where(whereExpression);
            }
            return up.ExecuteCommand();
        }
        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:40:18
        /// 任务编号:中餐
        /// </summary>
        /// <param name="columns">修改的列</param>
        /// <param name="whereExpression">条件表达式</param>
        /// <returns>是否成功</returns>
        public bool Update(Expression<Func<T, T>> columns, Expression<Func<T, bool>> whereExpression)
        {
            return _entityDB.Update(columns, whereExpression);
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:43:35
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entity">实体（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <returns>是否成功</returns>
        public bool Update(
            T entity,
            List<string> lstColumns,
            List<string> lstIgnoreColumns)
        {
            return Update(entity, lstColumns, lstIgnoreColumns, string.Empty);
        }

        /// <summary>
        /// 功能描述:修改指定的列和值
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-16 19:33:46
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="lstSetValueExpression">列和值列表(如：it => it.Name == (it.Name + 1))</param>
        /// <returns>是否成功</returns>
        public bool Update(string strWhere, params Expression<Func<T, bool>>[] lstSetValueExpression)
        {
            return Update(strWhere, null, lstSetValueExpression);
        }

        /// <summary>
        /// 功能描述:修改指定的列和值
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-16 19:34:01
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="lstParameters">参数</param>
        /// <param name="lstSetValueExpression">列和值列表(如：it => it.Name == (it.Name + 1))</param>
        /// <returns>是否成功</returns>
        public bool Update(
            string strWhere,
            List<SugarParameter> lstParameters,
            params Expression<Func<T, bool>>[] lstSetValueExpression
            )
        {
            IUpdateable<T> up = _db.Updateable<T>();
            if (lstSetValueExpression != null)
            {
                foreach (var item in lstSetValueExpression)
                {
                    up = up.ReSetValue(item);
                }
            }
            if (!string.IsNullOrEmpty(strWhere))
            {
                up = up.Where(strWhere, lstParameters);
            }

            return up.ExecuteCommand() > ;
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:43:35
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="strWhere">条件</param>
        /// <returns>是否成功</returns>
        public bool Update(
            T entity,
            List<string> lstColumns,
            List<string> lstIgnoreColumns,
            string strWhere)
        {
            IUpdateable<T> up = _db.Updateable(entity);
            if (lstIgnoreColumns != null && lstIgnoreColumns.Count > )
            {
                up = up.IgnoreColumns(it => lstIgnoreColumns.Contains(it));
            }
            if (lstColumns != null && lstColumns.Count > )
            {
                up = up.UpdateColumns(it => lstColumns.Contains(it));
            }
            if (!string.IsNullOrEmpty(strWhere))
            {
                up = up.Where(strWhere);
            }
            return up.ExecuteCommand() > ;
        }
        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 10:43:35
        /// 任务编号:中餐
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="strWhere">条件</param>
        /// <param name="lstParameters">参数</param>
        /// <returns>是否成功</returns>
        public bool Update(
            T entity,
            List<string> lstColumns,
            List<string> lstIgnoreColumns,
            string strWhere,
            List<SugarParameter> lstParameters)
        {
            IUpdateable<T> up = _db.Updateable(entity);
            if (lstIgnoreColumns != null && lstIgnoreColumns.Count > )
            {
                up = up.IgnoreColumns(it => lstIgnoreColumns.Contains(it));
            }
            if (lstColumns != null && lstColumns.Count > )
            {
                up = up.UpdateColumns(it => lstColumns.Contains(it));
            }
            if (!string.IsNullOrEmpty(strWhere))
            {
                up = up.Where(strWhere, lstParameters);
            }
            return up.ExecuteCommand() > ;
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-15 10:10:53
        /// 任务编号:中餐
        /// </summary>
        /// <param name="实体">entity</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="whereExpression">条件表达式</param>
        /// <returns>是否成功</returns>
        public bool Update(
         T entity,
         List<string> lstColumns,
         List<string> lstIgnoreColumns,
         Expression<Func<T, bool>> whereExpression)
        {
            IUpdateable<T> up = _db.Updateable(entity);
            if (lstIgnoreColumns != null && lstIgnoreColumns.Count > )
            {
                up = up.IgnoreColumns(it => lstIgnoreColumns.Contains(it));
            }
            if (lstColumns != null && lstColumns.Count > )
            {
                up = up.UpdateColumns(it => lstColumns.Contains(it));
            }
            if (whereExpression != null)
            {
                up = up.Where(whereExpression);
            }
            return up.ExecuteCommand() > ;
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-14 15:40:53
        /// 任务编号:中餐
        /// </summary>
        /// <param name="lstColumnValues">列，值</param>
        /// <param name="strWhere">条件</param>
        /// <param name="lstParameters">参数</param>
        /// <returns>是否成功</returns>
        public bool Update(
            Dictionary<string, object> lstColumnValues,
            string strWhere,
            List<SugarParameter> lstParameters)
        {
            IUpdateable<T> up = _db.Updateable<T>(lstColumnValues);
            if (!string.IsNullOrEmpty(strWhere))
            {
                up = up.Where(strWhere, lstParameters);
            }
            return up.ExecuteCommand() > ;
        }

        /// <summary>
        /// 功能描述:修改数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-14 15:42:27
        /// 任务编号:中餐
        /// </summary>
        /// <param name="lstColumnValues">列，值</param>
        /// <param name="whereExpression">条件</param>
        /// <returns>是否成功</returns>
        public bool Update(Dictionary<string, object> lstColumnValues, Expression<Func<T, bool>> whereExpression)
        {
            IUpdateable<T> up = _db.Updateable<T>(lstColumnValues);
            if (whereExpression != null)
            {
                up = up.Where(whereExpression);
            }
            return up.ExecuteCommand() > ;
        }
        #endregion

        #region 查
        /// <summary>
        /// 功能描述:数据条数
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-25 18:07:00
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">strWhere</param>
        /// <returns>返回值</returns>
        public int SelectCount(string strWhere)
        {
            return _db.Queryable<T>()
                .WhereIF(!string.IsNullOrEmpty(strWhere), strWhere)
                .Count();
        }
        /// <summary>
        /// 功能描述:查询所有数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 14:02:34
        /// 任务编号:中餐
        /// </summary>
        /// <returns>数据列表</returns>
        public List<T> Query()
        {
            return _entityDB.GetList();
        }

        /// <summary>
        /// 功能描述:查询数据列表
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-10 10:39:11
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <returns>数据列表</returns>
        public List<T> Query(string strWhere)
        {
            return _db.Queryable<T>().WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToList();
        }

        /// <summary>
        /// 功能描述:查询数据列表
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-10 10:40:32
        /// 任务编号:中餐
        /// </summary>
        /// <param name="whereExpression">whereExpression</param>
        /// <returns>数据列表</returns>
        public List<T> Query(Expression<Func<T, bool>> whereExpression)
        {
            return _entityDB.GetList(whereExpression);
        }
        /// <summary>
        /// 功能描述:查询一个列表
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:13:55
        /// 任务编号:中餐
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> Query(Expression<Func<T, bool>> whereExpression, string strOrderByFileds)
        {
            return _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).ToList();
        }

        /// <summary>
        /// 功能描述:查询一个列表
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:14:54
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> Query(string strWhere, string strOrderByFileds)
        {
            return _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToList();
        }

        /// <summary>
        /// 功能描述:查询一个列表
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:14:54
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="lstParameters">参数</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> Query(
            string strWhere,
            List<SugarParameter> lstParameters,
            string strOrderByFileds)
        {
            return _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere, lstParameters).ToList();
        }

        /// <summary>
        /// 功能描述:查询前N条数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:16:09
        /// 任务编号:中餐
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="intTop">前N条</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> Query(
            Expression<Func<T, bool>> whereExpression,
            int intTop,
            string strOrderByFileds)
        {
            return _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).Take(intTop).ToList();
        }

        /// <summary>
        /// 功能描述:查询前N条数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:17:14
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="intTop">前N条</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> Query(
            string strWhere,
            int intTop,
            string strOrderByFileds)
        {
            return _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).Take(intTop).ToList();
        }

        /// <summary>
        /// 功能描述:查询前N条数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:17:14
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="lstParameters">参数</param>
        /// <param name="intTop">前N条</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> Query(
            string strWhere,
            List<SugarParameter> lstParameters,
            int intTop,
            string strOrderByFileds)
        {
            return _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere, lstParameters).Take(intTop).ToList();
        }

        /// <summary>
        /// 功能描述:分页查询
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:27:17
        /// 任务编号:中餐
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="intPageIndex">页码（下标0）</param>
        /// <param name="intPageSize">页大小</param>
        /// <param name="intTotalCount">数据总量</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> Query(
            Expression<Func<T, bool>> whereExpression,
            int intPageIndex,
            int intPageSize,
            ref int intTotalCount,
            string strOrderByFileds)
        {
            return _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).ToPageList(intPageIndex, intPageSize, ref intTotalCount);
        }

        /// <summary>
        /// 功能描述:分页查询
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:29:07
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="intPageIndex">页码（下标0）</param>
        /// <param name="intPageSize">页大小</param>
        /// <param name="intTotalCount">数据总量</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> Query(
          string strWhere,
          int intPageIndex,
          int intPageSize,
          ref int intTotalCount,
          string strOrderByFileds)
        {
            return _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToPageList(intPageIndex, intPageSize, ref intTotalCount);
        }

        /// <summary>
        /// 功能描述:分页查询
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:29:07
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="lstParameters">参数</param>
        /// <param name="intPageIndex">页码（下标0）</param>
        /// <param name="intPageSize">页大小</param>
        /// <param name="intTotalCount">数据总量</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> Query(
          string strWhere,
          List<SugarParameter> lstParameters,
          int intPageIndex,
          int intPageSize,
          ref int intTotalCount,
          string strOrderByFileds)
        {
            return _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere, lstParameters).ToPageList(intPageIndex, intPageSize, ref intTotalCount);
        }

        /// <summary>
        /// 功能描述:根据ID查询一条数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:23:21
        /// 任务编号:中餐
        /// </summary>
        /// <param name="objId">id（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>数据实体</returns>
        public T QueryByID(object objId)
        {
            return _db.Queryable<T>().InSingle(objId);
        }
        /// <summary>
        /// 功能描述:根据ID查询一条数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-14 16:58:09
        /// 任务编号:中餐
        /// </summary>
        /// <param name="objId">id（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="blnUseCache">是否使用缓存</param>
        /// <param name="cacheDurationInSeconds">缓存超时时间（秒）</param>
        /// <returns>数据实体</returns>
        public T QueryByID(
            object objId,
            bool blnUseCache = false,
            int cacheDurationInSeconds = )
        {
            return _db.Queryable<T>().WithCacheIF(blnUseCache).InSingle(objId);
        }

        /// <summary>
        /// 功能描述:根据ID查询数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 11:23:34
        /// 任务编号:中餐
        /// </summary>
        /// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>数据实体列表</returns>
        public List<T> QueryByIDs(object[] lstIds)
        {
            return _db.Queryable<T>().In(lstIds).ToList();
        }
        /// <summary>
        /// 功能描述:根据ID查询一条数据
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-14 16:58:47
        /// 任务编号:中餐
        /// </summary>
        /// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="blnUseCache">是否使用缓存</param>
        /// <param name="cacheDurationInSeconds">缓存超时时间（秒）</param>
        /// <returns>数据实体列表</returns>
        public List<T> QueryByIDs(
            object[] lstIds,
            bool blnUseCache = false,
            int cacheDurationInSeconds = )
        {
            return _db.Queryable<T>().WithCacheIF(blnUseCache).In(lstIds).ToList();
        }

        #region QueryEntity
        /// <summary>
        /// 功能描述:查询一个实体
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-10 10:45:37
        /// 任务编号:中餐
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="blnUseCache">是否使用缓存机制</param>
        /// <param name="lstParameters">缓存过期时长</param>
        /// <returns>实体</returns>
        public T QueryEntity(
            Expression<Func<T, bool>> whereExpression,
            bool blnUseCache = false,
            int cacheDurationInSeconds = )
        {
            return _db.Queryable<T>().WithCacheIF(blnUseCache, cacheDurationInSeconds).WhereIF(whereExpression != null, whereExpression).First();
        }

        /// <summary>
        /// 功能描述:查询一个实体
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-10 10:45:44
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="lstParameters">参数</param>
        /// <param name="blnUseCache">是否使用缓存机制</param>
        /// <param name="lstParameters">缓存过期时长</param>
        /// <returns>实体</returns>
        public T QueryEntity(
            string strWhere,
            List<SugarParameter> lstParameters = null,
            bool blnUseCache = false,
            int cacheDurationInSeconds = )
        {
            return _db.Queryable<T>().WithCacheIF(blnUseCache, cacheDurationInSeconds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere, lstParameters).First();
        }

        #endregion

        #region QueryList
        /// <summary>
        /// 功能描述:查询一个列表
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-10 10:47:14
        /// 任务编号:中餐
        /// </summary>
        /// <param name="blnUseCache">是否使用缓存机制</param>
        /// <param name="lstParameters">缓存过期时长</param>
        /// <returns>返回值</returns>
        public List<T> QueryList(bool blnUseCache = false, int cacheDurationInSeconds = )
        {
            return _db.Queryable<T>().WithCacheIF(blnUseCache, cacheDurationInSeconds).ToList();
        }

        /// <summary>
        /// 功能描述:查询一个列表
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-10 10:50:32
        /// 任务编号:中餐
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="intTop">前N条数据</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <param name="blnUseCache">是否使用缓存机制</param>
        /// <param name="lstParameters">缓存过期时长</param>
        /// <returns>数据列表</returns>
        public List<T> QueryList(
            Expression<Func<T, bool>> whereExpression,
            int? intTop = null,
            string strOrderByFileds = null,
            bool blnUseCache = false,
            int cacheDurationInSeconds = )
        {
            ISugarQueryable<T> q = _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression);
            if (intTop.HasValue)
            {
                q = q.Take(intTop.Value);
            }
            return q.WithCacheIF(blnUseCache, cacheDurationInSeconds).ToList();
        }

        /// <summary>
        /// 功能描述:查询一个列表
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-10 10:52:17
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="lstParameters">参数</param>
        /// <param name="intTop">前N条数据</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <param name="blnUseCache">是否使用缓存机制</param>
        /// <param name="lstParameters">缓存过期时长</param>
        /// <returns>数据列表</returns>
        public List<T> QueryList(
            string strWhere,
            List<SugarParameter> lstParameters = null,
            int? intTop = null,
            string strOrderByFileds = null,
            bool blnUseCache = false,
            int cacheDurationInSeconds = )
        {
            ISugarQueryable<T> q = _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere, lstParameters);
            if (intTop.HasValue)
            {
                q = q.Take(intTop.Value);
            }
            return q.WithCacheIF(blnUseCache, cacheDurationInSeconds).ToList();
        }
        #endregion

        #region QueryPage
        /// <summary>
        /// 功能描述:分页查询
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-10 10:55:06
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="intTotalCount">数据总数</param>
        /// <param name="intPageIndex">当前页</param>
        /// <param name="intPageSize">页大小</param>
        /// <param name="lstParameters">参数</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> QueryPage(
         string strWhere,
         ref int intTotalCount,
         int intPageIndex = ,
         int intPageSize = ,
         List<SugarParameter> lstParameters = null,
         string strOrderByFileds = null)
        {
            return _db.Queryable<T>()
                .OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds)
                .WhereIF(!string.IsNullOrEmpty(strWhere), strWhere, lstParameters)
                .ToPageList(intPageIndex, intPageSize, ref intTotalCount);
        }

        /// <summary>
        /// 功能描述:分页查询
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-10 10:55:06
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="intTotalCount">数据总数</param>
        /// <param name="intPageIndex">当前页</param>
        /// <param name="intPageSize">页大小</param>
        /// <param name="lstParameters">参数</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public List<T> QueryPage(
         Expression<Func<T, bool>> whereExpression,
         ref int intTotalCount,
         int intPageIndex = ,
         int intPageSize = ,
         string strOrderByFileds = null)
        {
            return _db.Queryable<T>()
                .OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds)
                .WhereIF(whereExpression != null, whereExpression)
                .ToPageList(intPageIndex, intPageSize, ref intTotalCount);
        }
        #endregion

        /// <summary>
        /// 功能描述:查询Table
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-16 18:03:14
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strSql">strSql</param>
        /// <param name="lstParameters">参数</param>
        /// <returns>DataTable</returns>
        public DataTable QueryTable(string strSql, SugarParameter[] lstParameters = null)
        {
            return _db.Ado.GetDataTable(strSql, lstParameters);
        }

        /// <summary>
        /// 功能描述:查询DataSet
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-16 18:06:05
        /// 任务编号:中餐
        /// </summary>
        /// <param name="strSql">strSql</param>
        /// <param name="lstParameters">参数</param>
        /// <returns>DataSet</returns>
        public DataSet QueryDataSet(string strSql, SugarParameter[] lstParameters = null)
        {
            return _db.Ado.GetDataSetAll(strSql, lstParameters);
        }
        #endregion

        #region 事务
        /// <summary>
        /// 功能描述:开始事务
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 09:49:49
        /// 任务编号:中餐
        /// </summary>
        public void BeginTran()
        {
            _db.Ado.BeginTran();
        }

        /// <summary>
        /// 功能描述:提交事务
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 09:49:57
        /// 任务编号:中餐
        /// </summary>
        public void CommitTran()
        {
            _db.Ado.CommitTran();
        }

        /// <summary>
        /// 功能描述:回滚事务
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 09:50:01
        /// 任务编号:中餐
        /// </summary>
        public void RollbackTran()
        {
            _db.Ado.RollbackTran();
        }
        #endregion

        #region 其他
        /// <summary>
        /// 功能描述:获取数据库时间
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-09 19:41:31
        /// 任务编号:中餐
        /// </summary>
        /// <returns>返回值</returns>
        public DateTime GetDBTime()
        {
            return _db.GetDate();
        }

        /// <summary>
        /// 功能描述:清除表缓存
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-11 10:15:51
        /// 任务编号:中餐
        /// </summary>
        public void RemoveCache()
        {
            var cacheService = _db.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService;
            string tableName = _db.EntityMaintenance.GetTableName<T>();
            var keys = cacheService.GetAllKey<string>();
            if (keys != null && keys.Count() > )
            {
                foreach (var item in keys)
                {
                    if (item.ToLower().Contains("." + tableName.ToLower() + "."))
                    {
                        cacheService.Remove<string>(item);
                    }
                }
            }
        }

        /// <summary>
        /// 功能描述:关闭连接
        /// 作　　者:beck.huang
        /// 创建日期:2018-05-28 17:37:16
        /// 任务编号:中餐
        /// </summary>
        public void CloseDB()
        {
            if (_context != null && _context.Db != null)
            {
                _context.Db.Close();
                _context.Db.Dispose();
            }
        }
        #endregion

        #region 事件
        ///// <summary>
        ///// 功能描述:Sql执行完发生
        ///// 作　　者:beck.huang
        ///// 创建日期:2018-05-11 10:40:25
        ///// 任务编号:中餐
        ///// </summary>
        ///// <param name="sql">sql</param>
        ///// <param name="pars">pars</param>
        //public virtual void OnLogExecuted(string sql, SugarParameter[] pars)
        //{

        //}
        ///// <summary>
        ///// 功能描述:Sql执行前发生
        ///// 作　　者:beck.huang
        ///// 创建日期:2018-05-11 10:40:25
        ///// 任务编号:中餐
        ///// </summary>
        ///// <param name="sql">sql</param>
        ///// <param name="pars">pars</param>
        //public virtual void OnLogExecuting(string sql, SugarParameter[] pars)
        //{

        //}
        ///// <summary>
        ///// 功能描述:执行SQL 错误时发生
        ///// 作　　者:beck.huang
        ///// 创建日期:2018-05-11 10:40:25
        ///// 任务编号:中餐
        ///// </summary>
        ///// <param name="ex">错误</param>
        //public virtual void OnError(Exception ex)
        //{

        //}

        ///// <summary>
        ///// 功能描述:SQL执行前 可以修改SQL
        ///// 作　　者:beck.huang
        ///// 创建日期:2018-05-11 10:47:37
        ///// 任务编号:中餐
        ///// </summary>
        ///// <param name="sql">sql</param>
        ///// <param name="pars">pars</param>
        ///// <returns>返回值</returns>
        //public virtual KeyValuePair<string, SugarParameter[]> OnExecutingChangeSql(string sql, SugarParameter[] pars)
        //{
        //    return new KeyValuePair<string, SugarParameter[]>(sql, pars);
        //}
        #endregion

    }

HttpRuntimeCache

 using SqlSugar;
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Web;
 using System.Web.Caching;

 namespace Km.DB
 {
     public class HttpRuntimeCache : ICacheService
     {
         public void Add<V>(string key, V value)
         {
             HttpRuntimeCacheHelper<V>.GetInstance().Add(key, value);
         }

         public void Add<V>(string key, V value, int cacheDurationInSeconds)
         {
             HttpRuntimeCacheHelper<V>.GetInstance().Add(key, value, cacheDurationInSeconds);
         }

         public bool ContainsKey<V>(string key)
         {
             return HttpRuntimeCacheHelper<V>.GetInstance().ContainsKey(key);
         }

         public V Get<V>(string key)
         {
             return HttpRuntimeCacheHelper<V>.GetInstance().Get(key);
         }

         public IEnumerable<string> GetAllKey<V>()
         {
             return HttpRuntimeCacheHelper<V>.GetInstance().GetAllKey();
         }

         public V GetOrCreate<V>(string cacheKey, Func<V> create, int cacheDurationInSeconds = int.MaxValue)
         {
             var cacheManager = HttpRuntimeCacheHelper<V>.GetInstance();
             if (cacheManager.ContainsKey(cacheKey))
             {
                 return cacheManager[cacheKey];
             }
             else
             {
                 var result = create();
                 cacheManager.Add(cacheKey, result, cacheDurationInSeconds);
                 return result;
             }
         }

         public void Remove<V>(string key)
         {
             HttpRuntimeCacheHelper<V>.GetInstance().Remove(key);
         }
     }

     internal class HttpRuntimeCacheHelper<V>
     {

         #region 全局变量
         private static HttpRuntimeCacheHelper<V> _instance = null;
         private static readonly object _instanceLock = new object();
         #endregion

         #region 构造函数

         private HttpRuntimeCacheHelper() { }
         #endregion

         #region  属性
         /// <summary>
         ///根据key获取value
         /// </summary>
         /// <value></value>
         public V this[string key]
         {
             get { return (V)HttpRuntime.Cache[CreateKey(key)]; }
         }
         #endregion

         #region 公共函数

         /// <summary>
         /// key是否存在
         /// </summary>
         /// <param name="key">key</param>
         /// <returns> ///  存在<c>true</c> 不存在<c>false</c>.        /// /// </returns>
         public bool ContainsKey(string key)
         {
             return HttpRuntime.Cache[CreateKey(key)] != null;
         }

         /// <summary>
         /// 获取缓存值
         /// </summary>
         /// <param name="key">key</param>
         /// <returns></returns>
         public V Get(string key)
         {
             return (V)HttpRuntime.Cache.Get(CreateKey(key));
         }

         /// <summary>
         /// 获取实例 （单例模式）
         /// </summary>
         /// <returns></returns>
         public static HttpRuntimeCacheHelper<V> GetInstance()
         {
             if (_instance == null)
                 lock (_instanceLock)
                     if (_instance == null)
                         _instance = new HttpRuntimeCacheHelper<V>();
             return _instance;
         }

         /// <summary>
         /// 插入缓存(默认20分钟)
         /// </summary>
         /// <param name="key"> key</param>
         /// <param name="value">value</param>
         public void Add(string key, V value)
         {
             Add(key, value,  * );
         }

         /// <summary>
         /// 插入缓存
         /// </summary>
         /// <param name="key"> key</param>
         /// <param name="value">value</param>
         /// <param name="cacheDurationInSeconds">过期时间单位秒</param>
         public void Add(string key, V value, int cacheDurationInSeconds)
         {
             Add(key, value, cacheDurationInSeconds, CacheItemPriority.Default);
         }

         /// <summary>
         /// 插入缓存.
         /// </summary>
         /// <param name="key">key</param>
         /// <param name="value">value</param>
         /// <param name="cacheDurationInSeconds">过期时间单位秒</param>
         /// <param name="priority">缓存项属性</param>
         public void Add(string key, V value, int cacheDurationInSeconds, CacheItemPriority priority)
         {
             string keyString = CreateKey(key);
             HttpRuntime.Cache.Insert(keyString, value, null,
             DateTime.Now.AddSeconds(cacheDurationInSeconds), Cache.NoSlidingExpiration, priority, null);
         }

         /// <summary>
         /// 插入缓存.
         /// </summary>
         /// <param name="key">key</param>
         /// <param name="value">value</param>
         /// <param name="cacheDurationInSeconds">过期时间单位秒</param>
         /// <param name="priority">缓存项属性</param>
         public void Add(string key, V value, int
          cacheDurationInSeconds, CacheDependency dependency, CacheItemPriority priority)
         {
             string keyString = CreateKey(key);
             HttpRuntime.Cache.Insert(keyString, value,
              dependency, DateTime.Now.AddSeconds(cacheDurationInSeconds), Cache.NoSlidingExpiration, priority, null);
         }

         /// <summary>
         /// 删除缓存
         /// </summary>
         /// <param name="key">key</param>
         public void Remove(string key)
         {
             HttpRuntime.Cache.Remove(CreateKey(key));
         }

         /// <summary>
         /// 清除所有缓存
         /// </summary>
         public void RemoveAll()
         {
             System.Web.Caching.Cache cache = HttpRuntime.Cache;
             IDictionaryEnumerator CacheEnum = cache.GetEnumerator();
             ArrayList al = new ArrayList();
             while (CacheEnum.MoveNext())
             {
                 al.Add(CacheEnum.Key);
             }
             foreach (string key in al)
             {
                 cache.Remove(key);
             }
         }

         /// <summary>
         /// 清除所有包含关键字的缓存
         /// </summary>
         /// <param name="removeKey">关键字</param>
         public void RemoveAll(Func<string, bool> removeExpression)
         {
             System.Web.Caching.Cache _cache = System.Web.HttpRuntime.Cache;
             var allKeyList = GetAllKey();
             var delKeyList = allKeyList.Where(removeExpression).ToList();
             foreach (var key in delKeyList)
             {
                 HttpRuntime.Cache.Remove(key); ;
             }
         }

         /// <summary>
         /// 获取所有缓存key
         /// </summary>
         /// <returns></returns>
         public IEnumerable<string> GetAllKey()
         {
             IDictionaryEnumerator CacheEnum = HttpRuntime.Cache.GetEnumerator();
             while (CacheEnum.MoveNext())
             {
                 yield return CacheEnum.Key.ToString();
             }
         }
         #endregion

         #region 私有函数

         /// <summary>
         ///创建KEY
         /// </summary>
         /// <param name="key">Key</param>
         /// <returns></returns>
         private string CreateKey(string key)
         {
             return key;
         }
         #endregion
     }
 }

至于为什么要再封装一层，是为了学习成本，如果不封装，整个项目组大家都要学习Sqlsugar，封装了之后，只需要我自己学习就可以了，别人只用我封装的类就可以