使用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 > 0)
            {
                _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 = 0; 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) > 0;
        }
        /// <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 > 0)
            {
                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 0;
        }
        /// <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() > 0;
        }
        /// <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() > 0;
        }

        /// <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) > 0;
        }


        /// <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() > 0;
        }
        /// <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() > 0;
        }

        /// <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 > 0)
            {
                up = up.IgnoreColumns(it => lstIgnoreColumns.Contains(it));
            }
            if (lstColumns != null && lstColumns.Count > 0)
            {
                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 > 0)
            {
                up = up.IgnoreColumns(it => lstIgnoreColumns.Contains(it));
            }
            if (lstColumns != null && lstColumns.Count > 0)
            {
                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() > 0;
        }



        /// <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 > 0)
            {
                up = up.IgnoreColumns(it => lstIgnoreColumns.Contains(it));
            }
            if (lstColumns != null && lstColumns.Count > 0)
            {
                up = up.UpdateColumns(it => lstColumns.Contains(it));
            }
            if (!string.IsNullOrEmpty(strWhere))
            {
                up = up.Where(strWhere);
            }
            return up.ExecuteCommand() > 0;
        }
        /// <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 > 0)
            {
                up = up.IgnoreColumns(it => lstIgnoreColumns.Contains(it));
            }
            if (lstColumns != null && lstColumns.Count > 0)
            {
                up = up.UpdateColumns(it => lstColumns.Contains(it));
            }
            if (!string.IsNullOrEmpty(strWhere))
            {
                up = up.Where(strWhere, lstParameters);
            }
            return up.ExecuteCommand() > 0;
        }

        /// <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 > 0)
            {
                up = up.IgnoreColumns(it => lstIgnoreColumns.Contains(it));
            }
            if (lstColumns != null && lstColumns.Count > 0)
            {
                up = up.UpdateColumns(it => lstColumns.Contains(it));
            }
            if (whereExpression != null)
            {
                up = up.Where(whereExpression);
            }
            return up.ExecuteCommand() > 0;
        }

        /// <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() > 0;
        }

        /// <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() > 0;
        }
        #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 = 2147483647)
        {
            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 = 2147483647)
        {
            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 = 2147483647)
        {
            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 = 2147483647)
        {
            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 = 2147483647)
        {
            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 = 2147483647)
        {
            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 = 2147483647)
        {
            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 = 0,
         int intPageSize = 20,
         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 = 0,
         int intPageSize = 20,
         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() > 0)
            {
                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, 60 * 20);
        }

        /// <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，封装了之后，只需要我自己学习就可以了，别人只用我封装的类就可以