RCS / RCS_Differential_Slam_Changsha · Files

using RCS.Model.Comm;
using SqlSugar;
using System.Data;
using System.Linq.Expressions;

namespace RCS.Dal
{
    public class BaseDal<T> where T : class, new()
    {

        #region 属性字段

        private SqlSugarScope _db;
        private SimpleClient<T> _entityDB;

        #endregion 属性字段

        #region 构造函数

        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="scheme">对应的数据库名称</param>
        public BaseDal(string scheme = null)
        {
            if (string.IsNullOrEmpty(scheme))
            {
                _db = DbContext.DbDictionary.Values.First();
            }
            else
            {
                _db = DbContext.DbDictionary[DbContext.Scheme];
            }
            _entityDB = new SimpleClient<T>(_db);
        }

        #endregion 构造函数

        #region 增加

        /// <summary>
        /// 功能描述:插入数据组
        /// </summary>
        /// <param name="entitys">实体列表</param>
        /// <returns>是否成功</returns>
        public BllResult Insert(T entity)
        {
            try
            {
                if (entity == null)
                    return BllResult.Error("无插入数据");

                bool result = _db.Insertable(entity).ExecuteCommandIdentityIntoEntity(); ;
                if (result)
                    return BllResult.Success("成功");
                else
                    return BllResult.Error("新增0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Insert", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:插入数据组
        /// </summary>
        /// <param name="entitys">实体列表</param>
        /// <returns>是否成功</returns>
        public BllResult Insert(List<T> entitys)
        {
            try
            {
                if (entitys == null || entitys.Count == 0)
                    return BllResult.Error("无插入数据");

                bool result = _entityDB.InsertRange(entitys);
                if (result)
                    return BllResult.Success("成功");
                else
                    return BllResult.Error("新增0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Insert", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:插入数据，返回自增列表
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns>自增ID</returns>
        public BllResult<List<int>> InsertReturnPkList(List<T> entitys)
        {
            try
            {
                if (entitys == null || entitys.Count == 0)
                    return BllResult<List<int>>.Error("无插入数据");

                var result = _db.Insertable(entitys).ExecuteReturnPkList<int>();
                if (result.Count == entitys.Count)
                    return BllResult<List<int>>.Success(result, "成功");
                else
                    return BllResult<List<int>>.Error("新增0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("InsertReturnIdentity", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<int>>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:插入数据
        /// </summary>
        /// <param name="entitys">插入的实体类</param>
        /// <param name="lstIgnoreColumns">不更新的列名</param>
        /// <returns></returns>
        public BllResult Insert(T entity, Expression<Func<T, object>> lstIgnoreColumns)
        {
            try
            {
                if (entity == null)
                    return BllResult.Error("无插入数据");

                var result = _db.Insertable(entity).IgnoreColumns(lstIgnoreColumns).ExecuteCommand();
                if (result > 0)
                    return BllResult.Success("成功");
                else
                    return BllResult.Error("新增0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Insert", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }


        #endregion 增

        #region 删除

        /// <summary>
        /// 功能描述:删除指定实体
        /// </summary>
        /// <param name="entity">实体（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>是否成功</returns>
        public BllResult Delete(T entity)
        {
            try
            {
                _db.Deleteable<T>(entity).ExecuteCommand();
                return BllResult.Success("删除成功");
                //bool result = _entityDB.Delete(entity);
                //if (result)
                //    return BllResult.Sucess("删除成功");
                //else
                //    return BllResult.Error("删除0条数据");

            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Delete", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:删除数据组
        /// </summary>
        /// <param name="entitys">实体列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>受影响行数</returns>
        public BllResult<int> Delete(T[] entitys)
        {
            try
            {
                if (entitys != null && entitys.Length > 0)
                {
                    int result = _db.Deleteable<T>(entitys.ToList()).ExecuteCommand();
                    return BllResult<int>.Success(result, "删除成功");
                    //if (result > 0)
                    //return BllResult<int>.Sucess(result, "删除成功");
                    //else
                    //    return BllResult<int>.Error("删除0条数据");
                }
                else
                    return BllResult<int>.Error("无删除数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Delete", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<int>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:删除数据，根据Linq条件
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <returns>是否删除成功</returns>
        public BllResult Delete(Expression<Func<T, bool>> whereExpression)
        {
            try
            {
                _db.Deleteable<T>(whereExpression).ExecuteCommand();
                return BllResult.Success("删除成功");
                //bool result = _entityDB.Delete(whereExpression);
                //if (result)
                //    return BllResult.Sucess("删除成功");
                //else
                //    return BllResult.Error("删除0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Delete", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:删除数据，根据sql
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <returns>是否成功</returns>
        public BllResult Delete(string strWhere)
        {
            try
            {
                _db.Deleteable<T>().Where(strWhere).ExecuteCommand();
                return BllResult.Success("删除成功");
                //bool result = _db.Deleteable<T>().Where(strWhere).ExecuteCommand() > 0;
                //if (result)
                //    return BllResult.Sucess("删除成功");
                //else
                //    return BllResult.Error("删除0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Delete", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:根据ID删除数据组
        /// </summary>
        /// <param name="ids">主键列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>受影响行数</returns>
        public BllResult<int> DeleteByID(params object[] ids)
        {
            try
            {
                if (ids != null && ids.Length > 0)
                {
                    int result = _db.Deleteable<T>().In(ids).ExecuteCommand();
                    return BllResult<int>.Success(result, "删除成功");
                    //if (result > 0)
                    //    return BllResult<int>.Sucess(result, "删除成功");
                    //else
                    //    return BllResult<int>.Error("删除0条数据");
                }
                else
                    return BllResult<int>.Error("无删除数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("DeleteByID", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<int>.Error($"发生异常：{ex.Message}");
            }
        }


        #region 测试删除
        /// <summary>
        /// 模糊删除
        /// </summary>
        /// <param name="whereExpression">模糊删除条件</param>
        /// <param name="whereExpression1">AND特定条件</param>
        /// <returns></returns>
        public BllResult Delete(Expression<Func<T, bool>> whereExpression, Expression<Func<T, bool>> whereExpression1)
        {
            try
            {
                //配置表过滤器
                //提出需要查询的条件
                _db.QueryFilter.Add(new TableFilterItem<T>(whereExpression));

                //查询有效数据
                //SELECT * FROM [Table]  WHERE  ([Colums] like '%'+@MethodConst0+'%') 
                var st = _db.Queryable<T>().ToList();
                if (st.Count == 0)
                {
                    return BllResult.Success();
                }
                var outcome = _db.Deleteable<T>().EnableQueryFilter();
                //删除有效数据
                //DELETE FROM [Table] WHERE ([Colums] like '%'+@MethodConst1000+'%')
                if (whereExpression1 != null)
                {
                    //AND条件
                    //AND( [Colums] = @Id0 )
                    outcome = outcome.Where(whereExpression1);
                }
                var results = outcome.ExecuteCommand();
                //if (results < 1)
                //{
                //    return BllResult.Error($"发生异常：{ex.Message}");
                //}
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Delete(模糊)", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
            return BllResult.Success();
        }
        #endregion


        #endregion 删

        #region 修改

        /// <summary>
        /// 功能描述:修改数据，直接修改实体类
        /// </summary>
        /// <param name="entity">实体（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>是否成功</returns>
        public BllResult Update(T entity)
        {
            try
            {
                bool result = _entityDB.Update(entity);
                if (result)
                    return BllResult.Success("成功");
                else
                    return BllResult.Error("更新0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:修改数据，根据sql条件
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="entity">条件</param>
        /// <returns>是否成功</returns>
        public BllResult Update(T entity, string strWhere)
        {
            try
            {
                bool result = _db.Updateable(entity).Where(strWhere).ExecuteCommand() > 0;
                if (result)
                    return BllResult.Success("成功");
                else
                    return BllResult.Error("更新0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:修改数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="strWhere">条件</param>
        /// <returns>是否成功</returns>
        public BllResult Update(T entity, Expression<Func<T, object>> lstColumns, Expression<Func<T, object>> lstIgnoreColumns, string strWhere)
        {
            try
            {
                IUpdateable<T> up = _db.Updateable(entity);
                if (lstIgnoreColumns != null)
                {
                    up = up.IgnoreColumns(it => lstIgnoreColumns);
                }
                if (lstColumns != null)
                {
                    up = up.UpdateColumns(it => lstColumns);
                }
                if (!string.IsNullOrEmpty(strWhere))
                {
                    up = up.Where(strWhere);
                }
                bool result = up.ExecuteCommand() > 0;
                if (result)
                    return BllResult.Success(result, "成功");
                else
                    return BllResult.Error("更新0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }


        /// <summary>
        /// 功能描述:修改数据
        /// </summary>
        /// <param name="实体">entity</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="whereExpression">条件表达式</param>
        /// <returns>是否成功</returns>
        public BllResult Update(T entity, Expression<Func<T, object>> lstColumns, Expression<Func<T, object>> lstIgnoreColumns, Expression<Func<T, bool>> whereExpression)
        {
            try
            {
                IUpdateable<T> up = _db.Updateable(entity);
                if (lstIgnoreColumns != null)
                {
                    up = up.IgnoreColumns(it => lstIgnoreColumns);
                }
                if (lstColumns != null)
                {
                    up = up.UpdateColumns(it => lstColumns);
                }
                if (whereExpression != null)
                {
                    up = up.Where(whereExpression);
                }
                bool result = up.ExecuteCommand() > 0;
                if (result)
                    return BllResult.Success(result, "成功");
                else
                    return BllResult.Error("更新0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 根据指定条件更新数据
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <param name="lstcolumns">条件</param>
        /// <returns></returns>
        public BllResult Update(T entity, Expression<Func<T, object>> lstcolumns)
        {
            try
            {
                var result = _db.Updateable(entity).WhereColumns(lstcolumns).ExecuteCommand();
                if (result > 0)
                    return BllResult.Success(result, "成功");
                else
                    return BllResult.Error("更新0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:修改数据
        /// </summary>
        /// <param name="entity">实体（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <returns>是否成功</returns>
        public BllResult Update(T entity, Expression<Func<T, object>> lstColumns, Expression<Func<T, object>> lstIgnoreColumns)
        {
            try
            {
                return Update(entity, lstColumns, lstIgnoreColumns, string.Empty);
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error("更新0条数据");
            }
        }


        /// <summary>
        /// 功能描述:修改数据，修改实体类组
        /// </summary>
        /// <param name="entitys">实体列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>受影响行数</returns>
        public BllResult<int> Update(T[] entitys)
        {
            try
            {
                if (entitys != null && entitys.Length > 0)
                {
                    var res = _db.Updateable(entitys).ExecuteCommand();
                    if (res > 0)
                    {
                        return BllResult<int>.Success(res);
                    }
                    else
                    {
                        return BllResult<int>.Error("无更新数据");

                    }
                }
                else
                    return BllResult<int>.Error("无更新数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<int>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:修改数据,指定修改列和不修改的列
        /// </summary>
        /// <param name="entitys">实体列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <returns>受影响行数</returns>
        public BllResult<int> Update(T[] entitys, Expression<Func<T, object>> lstColumns, Expression<Func<T, object>> lstIgnoreColumns)
        {
            try
            {
                if (entitys != null && entitys.Length > 0)
                {
                    return Update(entitys, lstColumns, lstIgnoreColumns, "");
                }
                else
                    return BllResult<int>.Error("无更新数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<int>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:修改数据
        /// </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 BllResult<int> Update(T[] entitys, Expression<Func<T, object>> lstColumns, Expression<Func<T, object>> lstIgnoreColumns, string strWhere)
        {
            try
            {
                if (entitys != null && entitys.Length > 0)
                {
                    IUpdateable<T> up = _db.Updateable(entitys);
                    if (lstIgnoreColumns != null)
                    {
                        up = up.IgnoreColumns(it => lstIgnoreColumns);
                    }
                    if (lstColumns != null)
                    {
                        up = up.UpdateColumns(it => lstColumns);
                    }
                    if (!string.IsNullOrEmpty(strWhere))
                    {
                        up = up.Where(strWhere);
                    }
                    int result = up.ExecuteCommand();
                    return BllResult<int>.Success(result, "成功");
                }
                else
                    return BllResult<int>.Error("无更新数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<int>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:修改数据
        /// </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 BllResult<int> Update(T[] entitys, Expression<Func<T, object>>? lstColumns, Expression<Func<T, object>>? lstIgnoreColumns, Expression<Func<T, bool>> whereExpression)
        {
            try
            {
                IUpdateable<T> up = _db.Updateable(entitys);
                if (lstIgnoreColumns != null)
                {
                    up = up.IgnoreColumns(it => lstIgnoreColumns);
                }
                if (lstColumns != null)
                {
                    up = up.UpdateColumns(it => lstColumns);
                }
                if (whereExpression != null)
                {
                    up = up.Where(whereExpression);
                }
                int result = up.ExecuteCommand();
                return BllResult<int>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<int>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 根据指定条件更新数据
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <param name="lstcolumns">更新键的条件字段</param>
        /// <returns></returns>
        public BllResult Update(T[] entity, Expression<Func<T, object>> lstcolumns)
        {
            try
            {
                var result = _db.Updateable(entity).WhereColumns(lstcolumns).ExecuteCommand();
                if (result > 0)
                    return BllResult.Success(result, "成功");
                else
                    return BllResult.Error("更新0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:修改数据,指定修改列和不修改的列
        /// </summary>
        /// <param name="entitys">实体列表，不指定主键，用whereColumns参数指定更新的比较键</param>
        /// <param name="lstColumns">更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="lstIgnoreColumns">不更新的列，如果为空则不做限制(lstColumns与lstIgnoreColumns互斥)</param>
        /// <param name="whereColumns">比较的条件列</param>
        /// <returns>受影响行数</returns>
        public BllResult<int> Update(T[] entitys, Expression<Func<T, object>>? lstColumns, Expression<Func<T, object>>? lstIgnoreColumns, Expression<Func<T, object>> whereColumns)
        {
            try
            {
                if (entitys != null && entitys.Length > 0)
                {
                    IUpdateable<T> up = _db.Updateable(entitys).WhereColumns(whereColumns);
                    if (lstIgnoreColumns != null)
                    {
                        up = up.IgnoreColumns(lstIgnoreColumns);
                    }
                    if (lstColumns != null)
                    {
                        up = up.UpdateColumns(lstColumns);
                    }
                    int result = up.ExecuteCommand();
                    return BllResult<int>.Success(result, "成功");
                }
                else
                    return BllResult<int>.Error("无更新数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<int>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:修改数据
        /// </summary>
        /// <param name="lstColumnValues">列，值</param>
        /// <param name="whereExpression">条件</param>
        /// <returns>是否成功</returns>
        public BllResult Update(Dictionary<string, object> lstColumnValues, Expression<Func<T, bool>> whereExpression)
        {
            try
            {
                IUpdateable<T> up = _db.Updateable<T>(lstColumnValues);
                if (whereExpression != null)
                {
                    up = up.Where(whereExpression);
                }
                bool result = up.ExecuteCommand() > 0;
                if (result)
                    return BllResult.Success(result, "成功");
                else
                    return BllResult.Error("更新0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:修改数据
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="lstcolumns">需要修改的列</param>
        /// <returns>是否成功</returns>
        public BllResult Update(Expression<Func<T, bool>> whereExpression, Expression<Func<T, T>> lstcolumns)
        {
            try
            {
                bool result = _entityDB.Update(lstcolumns, whereExpression);
                if (result)
                    return BllResult.Success(result, "成功");
                else
                    return BllResult.Error("更新0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }
        public BllResult Update(Expression<Func<T, bool>> whereExpression, Expression<Func<T, T>> lstcolumns, bool flag)
        {
            try
            {
                bool result = _entityDB.Update(lstcolumns, whereExpression);
                if (result)
                    return BllResult.Success(result, "成功");
                else
                {
                    DbContext.Log?.Invoke("Update", $"更新表{typeof(T).Name}0条数据，条件：{whereExpression}，值{lstcolumns}", false);
                    return BllResult.Success("更新0条数据");

                }
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }
        /// <summary>
        /// 功能描述:修改指定的列和值
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="lstSetValueExpression">列和值列表(如：it => it.Name == (it.Name + 1))</param>
        /// <returns>是否成功</returns>
        public BllResult Update(string strWhere, params Action<T>[] lstSetValueExpression)
        {
            try
            {
                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);
                }
                bool result = up.ExecuteCommand() > 0;
                if (result)
                    return BllResult.Success(result, "成功");
                else
                    return BllResult.Error("更新0条数据");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        #endregion 修改

        #region 查

        /// <summary>
        /// 功能描述:数据sql查询条数
        /// </summary>
        /// <param name="strWhere">strWhere</param>
        /// <returns>返回值</returns>
        public BllResult<int> SelectCount(string strWhere)
        {
            try
            {
                int result = _db.Queryable<T>().WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).Count();
                return BllResult<int>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("SelectCount", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<int>.Error($"发生异常：{ex.Message}");
            }
        }

        public BllResult<int> SelectCount(Expression<Func<T, bool>> whereExpression)
        {
            try
            {
                int result = _entityDB.Count(whereExpression);
                return BllResult<int>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("SelectCount", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<int>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:查询所有数据
        /// </summary>
        /// <returns>数据列表</returns>
        public BllResult<List<T>> Query()
        {
            try
            {
                List<T> result = _entityDB.GetList();
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Query", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:查询数据列表，根据sql条件
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <returns>数据列表</returns>
        public BllResult<List<T>> Query(string strWhere)
        {
            try
            {
                List<T> result = _db.Queryable<T>().WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToList();
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Query", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:查询数据列表，根据linq条件
        /// </summary>
        /// <param name="whereExpression">whereExpression</param>
        /// <returns>数据列表</returns>
        public BllResult<List<T>> Query(Expression<Func<T, bool>> whereExpression)
        {
            try
            {
                List<T> result = _entityDB.GetList(whereExpression);
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Query", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:查询一个列表，根据linq条件，并排序
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public BllResult<List<T>> Query(Expression<Func<T, bool>> whereExpression, string strOrderByFileds)
        {
            try
            {
                List<T> result = _db.Queryable<T>()
                                    .OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds)
                                    .WhereIF(whereExpression != null, whereExpression)
                                    .ToList();
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Query", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:查询一个列表，根据sql条件，并排序
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public BllResult<List<T>> Query(string strWhere, string strOrderByFileds)
        {
            try
            {
                List<T> result = _db.Queryable<T>()
                                    .OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds)
                                    .WhereIF(!string.IsNullOrEmpty(strWhere), strWhere)
                                    .ToList();
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Query", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常{ex.Message}");
            }
        }


        /// <summary>
        /// 功能描述:查询前N条数据
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="intTop">前N条</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public BllResult<List<T>> Query(Expression<Func<T, bool>> whereExpression, int intTop, string strOrderByFileds)
        {
            try
            {
                List<T> result = _db.Queryable<T>()
                                    .OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds)
                                    .WhereIF(whereExpression != null, whereExpression)
                                    .Take(intTop)
                                    .ToList();
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Query", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:查询前N条数据
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="intTop">前N条</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public BllResult<List<TResult>> Query<TResult>(Expression<Func<T, bool>> whereExpression, Expression<Func<T, TResult>> selectExpression,
                                                       Expression<Func<T, object>> orderByExpression, int intTop)
        {
            try
            {
                List<TResult> result = _db.Queryable<T>()
                                          .OrderByIF(orderByExpression != null, orderByExpression)
                                          .WhereIF(whereExpression != null, whereExpression)
                                          .Select(selectExpression)
                                          .Take(intTop)
                                          .ToList();
                return BllResult<List<TResult>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Query", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<TResult>>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:查询前N条数据
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <param name="intTop">前N条</param>
        /// <param name="strOrderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public BllResult<List<T>> Query(string strWhere, int intTop, string strOrderByFileds)
        {
            try
            {
                List<T> result = _db.Queryable<T>()
                                    .OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds)
                                    .WhereIF(!string.IsNullOrEmpty(strWhere), strWhere)
                                    .Take(intTop)
                                    .ToList();
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Query", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }


        /// <summary>
        /// 功能描述:分页查询
        /// </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 BllResult<List<T>> Query(Expression<Func<T, bool>> whereExpression, int intPageIndex, int intPageSize, ref int intTotalCount, string strOrderByFileds)
        {
            try
            {
                List<T> result = _db.Queryable<T>()
                                    .OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds)
                                    .WhereIF(whereExpression != null, whereExpression)
                                    .ToPageList(intPageIndex, intPageSize, ref intTotalCount);
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Query", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:分页查询
        /// </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 BllResult<List<T>> Query(string strWhere, int intPageIndex, int intPageSize, ref int intTotalCount, string strOrderByFileds)
        {
            try
            {
                List<T> result = _db.Queryable<T>()
                                    .OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds)
                                    .WhereIF(!string.IsNullOrEmpty(strWhere), strWhere)
                                    .ToPageList(intPageIndex, intPageSize, ref intTotalCount);
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Query", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }


        /// <summary>
        /// 功能描述:根据ID查询一条数据
        /// </summary>
        /// <param name="objId">id（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>数据实体</returns>
        public BllResult<T> QueryByID(object objId)
        {
            try
            {
                T result = _db.Queryable<T>().InSingle(objId);
                return BllResult<T>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("QueryByID", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<T>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:根据ID查询一条数据
        /// </summary>
        /// <param name="objId">id（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="blnUseCache">是否使用缓存</param>
        /// <param name="cacheDurationInSeconds">缓存超时时间（秒）</param>
        /// <returns>数据实体</returns>
        public BllResult<T> QueryByID(object objId, bool blnUseCache = false)
        {
            try
            {
                T result = _db.Queryable<T>().WithCacheIF(blnUseCache).InSingle(objId);
                return BllResult<T>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("QueryByID", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<T>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:根据ID查询数据
        /// </summary>
        /// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>数据实体列表</returns>
        public BllResult<List<T>> QueryByIDs(object[] lstIds)
        {
            try
            {
                List<T> result = _db.Queryable<T>().In(lstIds).ToList();
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("QueryByID", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:根据ID查询一条数据
        /// </summary>
        /// <param name="lstIds">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="blnUseCache">是否使用缓存</param>
        /// <param name="cacheDurationInSeconds">缓存超时时间（秒）</param>
        /// <returns>数据实体列表</returns>
        public BllResult<List<T>> QueryByIDs(object[] lstIds, bool blnUseCache = false)
        {
            try
            {
                List<T> result = _db.Queryable<T>().WithCacheIF(blnUseCache).In(lstIds).ToList();
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("QueryByID", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        #region QueryEntity

        /// <summary>
        /// 功能描述:查询一个实体
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="blnUseCache">是否使用缓存机制</param>
        /// <param name="lstParameters">缓存过期时长</param>
        /// <returns>实体</returns>
        public BllResult<T> QueryEntity(Expression<Func<T, bool>> whereExpression, bool blnUseCache = false, int cacheDurationInSeconds = 2147483647)
        {
            try
            {
                T result = _db.Queryable<T>().WithCacheIF(blnUseCache, cacheDurationInSeconds).WhereIF(whereExpression != null, whereExpression).First();
                return BllResult<T>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("QueryEntity", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<T>.Error($"发生异常：{ex.Message}");
            }
        }



        /// <summary>
        /// 根据条件排序并查询指定数据
        /// </summary>
        /// <param name="whereExpression">查询条件</param>
        /// <param name="orderbyExpression">排序条件</param>
        /// <param name="orderByType">升序或降序（默认降序）</param>
        /// <returns></returns>
        public BllResult<T> QueryEntity(Expression<Func<T, bool>> whereExpression, Expression<Func<T, object>> orderbyExpression, OrderByType orderByType = OrderByType.Desc)
        {
            try
            {
                var getFirst = _db.Queryable<T>().Where(whereExpression).OrderBy(orderbyExpression, orderByType).First();
                return BllResult<T>.Success(getFirst, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("QueryByID", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<T>.Error($"发生异常：{ex.Message}");
            }
        }

        #endregion QueryEntity

        #region 查询列表

        /// <summary>
        /// 功能描述:查询一个列表
        /// </summary>
        /// <param name="blnUseCache">是否使用缓存机制</param>
        /// <param name="lstParameters">缓存过期时长</param>
        /// <returns>返回值</returns>
        public BllResult<List<T>> QueryList(bool blnUseCache = false, int cacheDurationInSeconds = 2147483647)
        {
            try
            {
                List<T> result = _db.Queryable<T>().WithCacheIF(blnUseCache, cacheDurationInSeconds).ToList();
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("QueryList", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 功能描述:查询一个列表
        /// </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 BllResult<List<T>> QueryList(Expression<Func<T, bool>> whereExpression, int? intTop = null, string strOrderByFileds = null, bool blnUseCache = false, int cacheDurationInSeconds = 2147483647)
        {
            try
            {
                ISugarQueryable<T> q = _db.Queryable<T>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression);
                if (intTop.HasValue)
                {
                    q = q.Take(intTop.Value);
                }
                List<T> result = q.WithCacheIF(blnUseCache, cacheDurationInSeconds).ToList();
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("QueryList", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        #endregion QueryList

        #region 分页查询

        /// <summary>
        /// 功能描述:分页查询
        /// </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 BllResult<List<T>> QueryPage(Expression<Func<T, bool>> whereExpression, ref int intTotalCount, int intPageIndex = 0, int intPageSize = 20, string strOrderByFileds = null)
        {
            try
            {
                List<T> result = _db.Queryable<T>()
                                    .OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds)
                                    .WhereIF(whereExpression != null, whereExpression)
                                    .ToPageList(intPageIndex, intPageSize, ref intTotalCount);
                return BllResult<List<T>>.Success(result, "成功");
            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("QueryPage", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult<List<T>>.Error($"发生异常：{ex.Message}");
            }
        }

        #endregion QueryPage



        #endregion 查

        #region 事务

        /// <summary>
        /// 功能描述:开始事务
        /// </summary>
        public void BeginTran()
        {
            _db.Ado.BeginTran();
        }

        /// <summary>
        /// 功能描述:提交事务
        /// </summary>
        public void CommitTran()
        {
            try
            {
                _db.Ado.CommitTran();
            }
            catch (Exception ex)
            {
                _db.Ado.Transaction = null;
                throw ex;
            }

        }

        /// <summary>
        /// 功能描述:回滚事务
        /// </summary>
        public void RollbackTran()
        {
            try
            {
                _db.Ado.RollbackTran();
            }
            catch (Exception ex)
            {
                _db.Ado.Transaction = null;
                throw ex;
            }
        }

        #endregion 事务

        #region 其他

        /// <summary>
        /// 功能描述:获取数据库时间
        /// </summary>
        /// <returns>返回值</returns>
        public DateTime GetDBTime()
        {
            return _db.GetDate();
        }

        /// <summary>
        /// 功能描述:清除表缓存
        /// </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>
        /// 功能描述:关闭连接
        /// </summary>
        public void CloseDB()
        {
            if (_db != null)
            {
                _db.Close();
                _db.Dispose();
            }
        }

        #endregion 其他

        #region 事件

        ///// <summary>
        ///// 功能描述:Sql执行完发生
        ///// </summary>
        ///// <param name="sql">sql</param>
        ///// <param name="pars">pars</param>
        //public virtual void OnLogExecuted(string sql, SugarParameter[] pars)
        //{
        //}
        ///// <summary>
        ///// 功能描述:Sql执行前发生
        ///// </summary>
        ///// <param name="sql">sql</param>
        ///// <param name="pars">pars</param>
        //public virtual void OnLogExecuting(string sql, SugarParameter[] pars)
        //{
        //}
        ///// <summary>
        ///// 功能描述:执行SQL 错误时发生
        ///// </summary>
        ///// <param name="ex">错误</param>
        //public virtual void OnError(Exception ex)
        //{
        //}

        ///// <summary>
        ///// 功能描述:SQL执行前 可以修改SQL
        ///// </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 事件

        #region 测试
        public BllResult Updatert(T UpdateObjs, Expression<Func<T, bool>> whereExpression, Expression<Func<T, T>> updateExpression)
        {
            try
            {

                //var findAgv = App.AgvList.Find(a => a.AgvNo == "A33_0003");
                //findAgv.IP = "12356";
                //var abc = new Base_Agv() { IP = "456" };
                //var result4 = _db.Updateable(UpdateObjs).UpdateColumns(whereExpression).ExecuteCommand();
                //var result4 = _db.Updateable(findAgv).UpdateColumns(a => new { a.IP }).ExecuteCommand();
                //var result4 = _db.Updateable<T>(a=>a==UpdateObjs).Where(whereExpression).ExecuteCommand();
                //bool result = _entityDB.Update(updateExpression, whereExpression);
                //var result4 = _db.Updateable<T>().SetColumns(it=> UpdateObjs).Where(whereExpression).ExecuteCommand();
                //var result5 = _db.Updateable(UpdateObjs).UpdateColumns(updateExpression).Where(whereExpression).ExecuteCommand();
                //var up = _db.Updateable<T>(UpdateObjs);
                //up = up.UpdateColumns<T>(updateExpression);
                //var result6 = up.Where(whereExpression).ExecuteCommand();
                //var result4 = _db.Updateable(UpdateObjs).UpdateColumns(updateExpression).ExecuteCommand();
                //var result4 = _db.Updateable(UpdateObjs).WhereColumns(whereExpression).ExecuteCommand();
                return BllResult.Success("成功");

            }
            catch (Exception ex)
            {
                DbContext.Log?.Invoke("Update", $"异常信息：{ex.Message}  \r\n 异常堆栈：{ex.StackTrace}", false);
                return BllResult.Error($"发生异常：{ex.Message}");
            }
        }

        #endregion
    }
}