SqlSugard封装

1、创建 IDbContext.cs

复制代码
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BoZhon.Data.SqlSugar.DbContext
{
    public interface IDbContext
    {
        /// <summary>
        /// 操作数据库对象
        /// </summary>
        SqlSugarClient db { get; }

        /// <summary>
        /// 创建数据表
        /// </summary>
        /// <param name="Backup">是否备份</param>
        /// <param name="StringDefaultLength">string类型映射的长度</param>
        /// <param name="types">要创建的数据表</param>
        void CreateTable(bool Backup = false, int StringDefaultLength = 50, params Type[] types);
        
        /// <summary>
        /// 创建表
        /// </summary>
        /// <param name="Backup">是否备份</param>
        /// <param name="StringDefaultLength">string类型映射的长度</param>
        void CreateAllTable(bool Backup = false, int StringDefaultLength = 50);
    }
}
复制代码

2、创建 AppDbContext.cs ，实现 IDbContext

复制代码
using BoZhon.Util;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace BoZhon.Data.SqlSugar.DbContext
{
    /// <summary>
    /// 数据库上下文
    /// </summary>
    public class AppDbContext : IDbContext
    {
        //获取配置文件中的连接属性
        private string DBConnectionString = Configs.GetValue("DBConnectionString");
        private string DBProvider = Configs.GetValue("DBProvider");

        /// <summary>
        /// 返回数据库类型实例
        /// </summary>
        /// <returns></returns>
        private DbType getdbType()
        {
            switch (DBProvider)
            {
                case "MySql":
                    return DbType.MySql;
                case "SqlServer":
                    return DbType.SqlServer;
                case "Sqlite":
                    return DbType.Sqlite;
                case "Oracle":
                    return DbType.Oracle;
                default:
                    throw new Exception("数据库类型目前不支持！");
            }
        }

        /// <summary>
        /// 操作数据库对象
        /// </summary>
        public SqlSugarClient db
        {
            get
            {
                return new SqlSugarClient(new ConnectionConfig()
                {
                    ConnectionString = DBConnectionString,
                    DbType = getdbType(),
                    IsAutoCloseConnection = true,
                    InitKeyType = InitKeyType.Attribute,
                    AopEvents= new AopEvents { 
                        OnLogExecuting = (sql, paramster) => {
                            //string sa = sql;
                            Debug.Print(sql + $"\r\n" + $"{db.Utilities.SerializeObject(paramster.ToDictionary(it => it.ParameterName, it => it.Value))} \r\n");
                        }
                    }
                });
            }
        }

        /// <summary>
        /// 创建数据表
        /// </summary>
        /// <param name="Backup">是否备份</param>
        /// <param name="StringDefaultLength">string类型映射的长度</param>
        /// <param name="types">要创建的数据表</param>
        public void CreateTable(bool Backup = false, int StringDefaultLength = 50, params Type[] types)
        {
            //设置varchar的默认长度
            db.CodeFirst.SetStringDefaultLength(StringDefaultLength);

            //创建表
            if (Backup)
            {
                db.CodeFirst.BackupTable().InitTables(types);
            }
            else
            {
                db.CodeFirst.InitTables(types);
            }
        }

        /// <summary>
        /// 创建表
        /// </summary>
        /// <param name="Backup">是否备份</param>
        /// <param name="StringDefaultLength">string类型映射的长度</param>
        public void CreateAllTable(bool Backup = false, int StringDefaultLength = 50)
        {
            //设置varchar的默认长度
            db.CodeFirst.SetStringDefaultLength(StringDefaultLength);

            Assembly assembly = Assembly.Load("SqlSugar.Model");
            Type[] types = assembly.GetTypes().Where(t => t.FullName.Contains("Models")).ToArray();

            bool b = db.DbMaintenance.CreateDatabase();
            //创建表
            if (Backup)
            {
                db.CodeFirst.BackupTable().InitTables(types);
            }
            else
            {
                db.CodeFirst.InitTables(types);
            }

        }

    }

}
复制代码

3、创建仓储 IBaseRepository.cs

复制代码
using BoZhon.Util.Model;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace BoZhon.Data.SqlSugar.Repository
{
    public interface IBaseRepository<T> where T : class, new()
    {
        #region 新增

        /// <summary>
        /// 增加单条数据
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <returns>操作是否成功</returns>
        Task<bool> Add(T model);

        /// <summary>
        /// 增加多条数据
        /// </summary>
        /// <param name="list">实体集合</param>
        /// <returns>操作是否成功</returns>
        Task<bool> AddRange(List<T> list);


        /// <summary>
        /// 添加单条数据，并返回 自增列
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <returns></returns>
        Task<bool> AddReturnIdentity(T model);

        /// <summary>
        /// 增加单条数据 ，并返回 实体
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <returns></returns>
        Task<T> AddReturnEntity(T model);


        /// <summary>
        /// 只添加指定列
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="columns">指定要添加的列</param>
        /// <returns></returns>
        Task<bool> AddColumns(T model, params string[] columns);


        /// <summary>
        /// 不插入指定列
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="IgnoreColumns">要忽略的列</param>
        /// <returns></returns>
        Task<bool> AddColumnsByIgnoreColumns(T model, params string[] IgnoreColumns);


        #endregion

        #region 删除

        /// <summary>
        /// 根据主键删除，并返回操作是否成功
        /// </summary>
        /// <typeparam name="S">主键的类型</typeparam>
        /// <param name="key">主键</param>
        /// <returns></returns>
        Task<bool> Delete<S>(S key);


        /// <summary>
        /// 根据主键删除，并返回操作是否成功
        /// </summary>
        /// <typeparam name="S">主键类型</typeparam>
        /// <param name="keys">主键</param>
        /// <returns></returns>
        Task<bool> DeleteRange<S>(params S[] keys);


        /// <summary>
        /// 根据条件删除，并返回操作是否成功
        /// </summary>
        /// <param name="where">条件</param>
        /// <returns></returns>
        Task<bool> DeleteWhere(Expression<Func<T, bool>> where);


        #endregion

        #region 修改

        /// <summary>
        /// 根据主键更新 ，返回操作是否成功
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        Task<bool> Update(T model);


        /// <summary>
        /// 根据主键更新，返回操作是否成功
        /// </summary>
        /// <param name="list">实体集合</param>
        /// <returns></returns>
        Task<bool> UpdateRange(List<T> list);


        /// <summary>
        /// 根据指定 列条件 更新 ，并返回操作是否成功
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="expression">列条件 例如： t=>t.id>5 </param>
        Task<bool> Update(T model, Expression<Func<T, object>> expression);


        /// <summary>
        /// 根据主键，更新指定列,返回操作是否成功
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="columns">要更新的列</param>
        /// <returns></returns>
        Task<bool> UpdateColumns(T model, params string[] columns);


        /// <summary>
        /// 根据主键，更新指定列,返回操作是否成功
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="columns">要更新的列</param>
        /// <returns></returns>
        Task<bool> UpdateColumns(T model, Expression<Func<T, object>> columns);


        /// <summary>
        /// 根据主键 ， 忽略更新指定列，返回操作是否成功
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="columns">不更新的 忽略列</param>
        /// <returns></returns>
        Task<bool> UpdateColumnsByIgnoreColumns(T model, params string[] columns);


        /// <summary>
        /// 根据主键 ， 忽略更新指定列，返回操作是否成功
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="columns">不更新的 忽略列</param>
        /// <returns></returns>
        Task<bool> UpdateColumnsByIgnoreColumns(T model, Expression<Func<T, object>> columns);

        /// <summary>
        /// 根据主键更新 列
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="ignoreAllNullColumns">是否 NULL的列不更新</param>
        /// <param name="isOffIdentity">是否忽略 自增列</param>
        /// <param name="ignoreAllDefaultValue">是否 忽略默认值列</param>
        /// <returns></returns>
        Task<bool> UpdateNotNullColumns(T model, bool ignoreAllNullColumns, bool isOffIdentity = false, bool ignoreAllDefaultValue = false);


        //4.6.0.7 联表更新

        /// <summary>
        /// //根据不同条件执行更新不同的列 
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="dic">条件（key：要更新的列，value：条件是否更新此列）</param>
        /// <returns></returns>
        Task<bool> UpdateIF(T model, Dictionary<Expression<Func<T, object>>, bool> dic);


        #endregion

        #region 查询

        /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <returns></returns>
        Task<List<T>> getAll(bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 取前 num 条数据
        /// </summary>
        /// <param name="num">取前几条</param>
        /// <returns></returns>
        Task<List<T>> getTakeList(int num, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 获取单表 分页数据
        /// </summary>
        /// <param name="skip">跳过几条</param>
        /// <param name="take">取几条</param>
        /// <param name="whereExp">跳过几条</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        Task<List<T>> getPageList(int skip, int take, Expression<Func<T, bool>> whereExp, Expression<Func<T, object>> orderBy, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 获取符合条件的前 num 条数据
        /// </summary>
        /// <param name="where">条件</param>
        /// <param name="num">取前几条</param>
        /// <returns></returns> 
        Task<List<T>> getTakeList(Expression<Func<T, bool>> where, int num, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 根据主键查询
        /// </summary>
        /// <param name="pkValue">主键</param>
        /// <returns></returns>
        Task<T> getByPrimaryKey(object pkValue);


        /// <summary>
        /// 根据条件获取 单条数据 
        /// </summary>
        /// <param name="where">条件</param>
        /// <returns></returns>
        Task<T> getFirstOrDefault(Expression<Func<T, bool>> where);


        /// <summary>
        /// 根据主键 In  查询
        /// </summary>
        /// <typeparam name="S">主键的类型</typeparam>
        /// <param name="list">主键 In 操作的结果集</param>
        /// <returns></returns>
        Task<List<T>> getByIn<S>(List<S> list, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 根据指定列 In 查询
        /// </summary>
        /// <typeparam name="S">指定列的类型</typeparam>
        /// <param name="column">指定列</param>
        /// <param name="list">指定列 In 操作 的结果集</param>
        /// <returns></returns>
        Task<List<T>> getByIn<S>(Expression<Func<T, object>> column, List<S> list, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 根据指定列 Not In (!Contain)查询
        /// </summary>
        /// <typeparam name="S">指定列类型</typeparam>
        /// <param name="list">Not In的结果集</param>
        /// <param name="field">指定列</param>
        /// <returns></returns>
        Task<List<T>> getByNotIn<S>(List<S> list, object field, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 根据条件 查询
        /// </summary>
        /// <param name="where">条件</param>
        /// <returns></returns>
        Task<List<T>> getByWhere(Expression<Func<T, bool>> where, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 单个条件 根据 isWhere 判断 是否使用此条件进行查询
        /// </summary>
        /// <param name="isWhere">判断是否使用此查询条件的条件</param>
        /// <param name="where">查询条件</param>
        /// <returns></returns>
        Task<List<T>> getByWhereIF(bool isWhere, Expression<Func<T, bool>> where, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 多个条件 根据 wheres.value  判断是否使用 此 wheres.key 的条件
        /// </summary>
        /// <param name="wheres">查询条件</param>
        /// <returns></returns>
        Task<List<T>> getByWhereIF(Dictionary<Expression<Func<T, bool>>, bool> wheres, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 查询 指定列的值 在 start至end 之间的数据
        /// </summary>
        /// <param name="value">指定类</param>
        /// <param name="start">开始</param>
        /// <param name="end">结束</param>
        /// <returns></returns>
        Task<List<T>> getByBetween(object value, object start, object end, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 判断是否存在这条记录
        /// </summary>
        /// <param name="where">条件</param>
        /// <returns></returns>
        Task<bool> getIsAny(Expression<Func<T, bool>> where);


        /// <summary>
        /// 单表分页查询
        /// </summary>
        /// <typeparam name="T">要查询的表</typeparam>
        /// <param name="pagination">分页参数</param>
        /// <param name="isWhere">是否需要条件查询</param>
        /// <param name="whereExp">查询条件</param>
        /// <param name="isOrderBy">是否需要排序条件</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        Task<List<T>> getPageList(Pagination pagination, bool isWhere = false, Expression<Func<T, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 两表查询，
        /// </summary>
        /// <typeparam name="T1">左表</typeparam>
        /// <typeparam name="T2">右表</typeparam>
        /// <param name="joinExp">联表方式，联表字段（主外键关系）</param>
        /// <param name="selectExp">联表查询的结果</param>
        /// <param name="isWhere">是否需要查询条件</param>
        /// <param name="whereExp">条件查询</param>
        /// <param name="isOrderBy">是否需要排序</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        Task<dynamic> getJoinList<T1, T2>(Expression<Func<T1, T2, JoinQueryInfos>> joinExp, Expression<Func<T1, T2, dynamic>> selectExp, bool isWhere = false, Expression<Func<T1, T2, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T1, T2, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 两表 分页查询，
        /// </summary>
        /// <typeparam name="T1">左表</typeparam>
        /// <typeparam name="T2">右表</typeparam>
        /// <param name="pagination">分页参数</param>
        /// <param name="joinExp">联表方式，联表字段（主外键关系）</param>
        /// <param name="selectExp">联表查询的结果</param>
        /// <param name="isWhere">是否需要查询条件</param>
        /// <param name="whereExp">条件查询</param>
        /// <param name="isOrderBy">是否需要排序</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        Task<dynamic> getJoinPageList<T1, T2>(Pagination pagination, Expression<Func<T1, T2, JoinQueryInfos>> joinExp, Expression<Func<T1, T2, dynamic>> selectExp, bool isWhere = false, Expression<Func<T1, T2, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T1, T2, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 三表连接 查询
        /// </summary>
        /// <typeparam name="T1">表1</typeparam>
        /// <typeparam name="T2">表2</typeparam>
        /// <typeparam name="T3">表3</typeparam>
        /// <param name="joinExp">联表方式，联表字段（主外键关系）</param>
        /// <param name="selectExp">联表查询的结果</param>
        /// <param name="isWhere">是否需要查询条件</param>
        /// <param name="whereExp">查询条件</param>
        /// <param name="isOrderBy">是否需要排序条件</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        Task<dynamic> getJoinList<T1, T2, T3>(Expression<Func<T1, T2, T3, JoinQueryInfos>> joinExp, Expression<Func<T1, T2, T3, dynamic>> selectExp, bool isWhere = false, Expression<Func<T1, T2, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T1, T2, T3, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 三表连接 分页 查询
        /// </summary>
        /// <typeparam name="T1">表1</typeparam>
        /// <typeparam name="T2">表2</typeparam>
        /// <typeparam name="T3">表3</typeparam>
        /// <param name="pagination">分页参数</param>
        /// <param name="joinExp">联表方式，联表字段（主外键关系）</param>
        /// <param name="selectExp">联表查询的结果</param>
        /// <param name="isWhere">是否需要查询条件</param>
        /// <param name="whereExp">查询条件</param>
        /// <param name="isOrderBy">是否需要排序条件</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        Task<dynamic> getJoinList<T1, T2, T3>(Pagination pagination, Expression<Func<T1, T2, T3, JoinQueryInfos>> joinExp, Expression<Func<T1, T2, T3, dynamic>> selectExp, bool isWhere = false, Expression<Func<T1, T2, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T1, T2, T3, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc);


        /// <summary>
        /// 执行查询sql语句 ，返回数据集
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <returns></returns>
        Task<List<T>> getListBySql(string sql);


        /// <summary>
        /// 执行非查询sql语句，返回操作是否成功
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">参数化</param>
        /// <returns></returns>
        Task<bool> ExecuteCommandSql(string sql, List<SugarParameter> parameters);


        /// <summary>
        /// 执行查询sql语句，返回查询的结果集
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">参数化</param>
        /// <returns></returns>
        Task<List<T>> getListBySqlQuery(string sql, List<SugarParameter> parameters);


        /// <summary>
        /// 执行查询sql语句，返回 第一行第一列
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">参数化</param>
        /// <returns></returns>
        Task<object> getScalar(string sql, List<SugarParameter> parameters);



        #endregion

        #region 其他


        /// <summary>
        /// 使用存储过程，返回结果集
        /// </summary>
        /// <param name="procedureName">存储过程名称 </param>
        /// <param name="parameters">参数，支持 output</param>
        /// <returns></returns>
        Task<DataTable> UseStoredProcedure(string procedureName, List<SugarParameter> parameters);


        /// <summary>
        /// 使用事务 ，无返回值
        /// </summary>
        /// <param name="action">执行动作</param>
        /// <param name="errorCallBack">错误回调</param>
        Task<DbResult<bool>> UseTran(Func<Task> func, Action<Exception> errorCallBack);


        /// <summary>
        /// 使用事务，有返回值
        /// </summary>
        /// <typeparam name="S">返回值类型</typeparam>
        /// <param name="func">执行动作</param>
        /// <param name="errorCallBack">错误回调</param>
        Task<DbResult<S>> UseTran<S>(Func<Task<S>> func, Action<Exception> errorCallBack);


        #endregion
    }
}
复制代码

4、实现仓储 BaseRepository.cs

复制代码
using BoZhon.Data.SqlSugar.DbContext;
using BoZhon.Util.Model;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace BoZhon.Data.SqlSugar.Repository
{
    public class BaseRepository<T> : IBaseRepository<T> where T : class, new()
    {
        public readonly IDbContext context = new AppDbContext();

        #region 新增

        /// <summary>
        /// 增加单条数据
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <returns>操作是否成功</returns>
        public async Task<bool> Add(T model)
        {
            return await context.db.Insertable<T>(model).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 增加多条数据
        /// </summary>
        /// <param name="list">实体集合</param>
        /// <returns>操作是否成功</returns>
        public async Task<bool> AddRange(List<T> list)
        {
            return await context.db.Insertable<T>(list).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 添加单条数据，并返回 自增列
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <returns></returns>
        public async Task<bool> AddReturnIdentity(T model)
        {
            return await context.db.Insertable<T>(model).ExecuteReturnIdentityAsync() > 0;//ExecuteReturnBigIdentity();//4.5.0.2 +  long
        }

        /// <summary>
        /// 增加单条数据 ，并返回 实体
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <returns></returns>
        public async Task<T> AddReturnEntity(T model)
        {
            return await context.db.Insertable<T>(model).ExecuteReturnEntityAsync();
        }

        /// <summary>
        /// 只添加指定列
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="columns">指定要添加的列</param>
        /// <returns></returns>
        public async Task<bool> AddColumns(T model, params string[] columns)
        {
            return await context.db.Insertable<T>(model).InsertColumns(columns).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 不插入指定列
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="IgnoreColumns">要忽略的列</param>
        /// <returns></returns>
        public async Task<bool> AddColumnsByIgnoreColumns(T model, params string[] IgnoreColumns)
        {
            return await context.db.Insertable<T>(model)
                .IgnoreColumns(IgnoreColumns).ExecuteCommandAsync() > 0;
        }

        #endregion

        #region 删除

        /// <summary>
        /// 根据主键删除，并返回操作是否成功
        /// </summary>
        /// <typeparam name="S">主键的类型</typeparam>
        /// <param name="key">主键</param>
        /// <returns></returns>
        public async Task<bool> Delete<S>(S key)
        {
            return await context.db.Deleteable<T>().In(key).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 根据主键删除，并返回操作是否成功
        /// </summary>
        /// <typeparam name="S">主键类型</typeparam>
        /// <param name="keys">主键</param>
        /// <returns></returns>
        public async Task<bool> DeleteRange<S>(params S[] keys)
        {
            return await context.db.Deleteable<T>().In(keys).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 根据条件删除，并返回操作是否成功
        /// </summary>
        /// <param name="where">条件</param>
        /// <returns></returns>
        public async Task<bool> DeleteWhere(Expression<Func<T, bool>> where)
        {
            return await context.db.Deleteable<T>().Where(where).ExecuteCommandAsync() > 0;
        }

        #endregion

        #region 修改

        /// <summary>
        /// 根据主键更新 ，返回操作是否成功
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public async Task<bool> Update(T model)
        {
            return await context.db.Updateable<T>(model).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 根据主键更新，返回操作是否成功
        /// </summary>
        /// <param name="list">实体集合</param>
        /// <returns></returns>
        public async Task<bool> UpdateRange(List<T> list)
        {
            return await context.db.Updateable<T>(list).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 根据指定 列条件 更新 ，并返回操作是否成功
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="expression">列条件 例如： t=>t.id>5 </param>
        public async Task<bool> Update(T model, Expression<Func<T, object>> expression)
        {
            return await context.db.Updateable<T>(model).WhereColumns(expression).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 根据主键，更新指定列,返回操作是否成功
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="columns">要更新的列</param>
        /// <returns></returns>
        public async Task<bool> UpdateColumns(T model, params string[] columns)
        {
            return await context.db.Updateable<T>(model).UpdateColumns(columns).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 根据主键，更新指定列,返回操作是否成功
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="columns">要更新的列</param>
        /// <returns></returns>
        public async Task<bool> UpdateColumns(T model, Expression<Func<T, object>> columns)
        {
            return await context.db.Updateable<T>(model).UpdateColumns(columns).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 根据主键 ， 忽略更新指定列，返回操作是否成功
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="columns">不更新的 忽略列</param>
        /// <returns></returns>
        public async Task<bool> UpdateColumnsByIgnoreColumns(T model, params string[] columns)
        {
            return await context.db.Updateable<T>(model).IgnoreColumns(columns).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 根据主键 ， 忽略更新指定列，返回操作是否成功
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="columns">不更新的 忽略列</param>
        /// <returns></returns>
        public async Task<bool> UpdateColumnsByIgnoreColumns(T model, Expression<Func<T, object>> columns)
        {
            return await context.db.Updateable<T>(model).IgnoreColumns(columns).ExecuteCommandAsync() > 0;
        }

        /// <summary>
        /// 根据主键更新 列
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="ignoreAllNullColumns">是否 NULL的列不更新</param>
        /// <param name="isOffIdentity">是否忽略 自增列</param>
        /// <param name="ignoreAllDefaultValue">是否 忽略默认值列</param>
        /// <returns></returns>
        public async Task<bool> UpdateNotNullColumns(T model, bool ignoreAllNullColumns, bool isOffIdentity = false, bool ignoreAllDefaultValue = false)
        {
            return await context.db.Updateable<T>(model)
                .IgnoreColumns(ignoreAllNullColumns: true, isOffIdentity: false, ignoreAllDefaultValue: false)
                .ExecuteCommandAsync() > 0;
        }

        //4.6.0.7 联表更新

        /// <summary>
        /// //根据不同条件执行更新不同的列 
        /// </summary>
        /// <param name="model">实体对象</param>
        /// <param name="dic">条件（key：要更新的列，value：条件是否更新此列）</param>
        /// <returns></returns>
        public async Task<bool> UpdateIF(T model, Dictionary<Expression<Func<T, object>>, bool> dic)
        {
            var able = context.db.Updateable<T>(model);
            foreach (var item in dic)
            {
                able.UpdateColumnsIF(item.Value, item.Key);// s=>s.name  ture
            }

            return await able.ExecuteCommandAsync() > 0;
        }

        #endregion

        #region 查询

        /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <returns></returns>
        public async Task<List<T>> getAll(bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().OrderByIF(isOrderBy, orderBy, orderByType).ToListAsync();
        }

        /// <summary>
        /// 取前 num 条数据
        /// </summary>
        /// <param name="num">取前几条</param>
        /// <returns></returns>
        public async Task<List<T>> getTakeList(int num, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().OrderByIF(isOrderBy, orderBy, orderByType).Take(num).ToListAsync();
        }

        /// <summary>
        /// 获取单表 分页数据
        /// </summary>
        /// <param name="skip">跳过几条</param>
        /// <param name="take">取几条</param>
        /// <param name="whereExp">跳过几条</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        public async Task<List<T>> getPageList(int skip, int take, Expression<Func<T, bool>> whereExp, Expression<Func<T, object>> orderBy, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().Skip(skip).Take(take).OrderBy(orderBy, orderByType).ToListAsync();
        }

        /// <summary>
        /// 获取符合条件的前 num 条数据
        /// </summary>
        /// <param name="where">条件</param>
        /// <param name="num">取前几条</param>
        /// <returns></returns> 
        public async Task<List<T>> getTakeList(Expression<Func<T, bool>> where, int num, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().Where(where).OrderByIF(isOrderBy, orderBy, orderByType).Take(num).ToListAsync();
        }

        /// <summary>
        /// 根据主键查询
        /// </summary>
        /// <param name="pkValue">主键</param>
        /// <returns></returns>
        public async Task<T> getByPrimaryKey(object pkValue)
        {
            return await context.db.Queryable<T>().InSingleAsync(pkValue);
        }

        /// <summary>
        /// 根据条件获取 单条数据 
        /// </summary>
        /// <param name="where">条件</param>
        /// <returns></returns>
        public async Task<T> getFirstOrDefault(Expression<Func<T, bool>> where)
        {
            return await context.db.Queryable<T>().FirstAsync(where);//查询单条没有数据返回NULL, Single超过1条会报错，First不会
        }

        /// <summary>
        /// 根据主键 In  查询
        /// </summary>
        /// <typeparam name="S">主键的类型</typeparam>
        /// <param name="list">主键 In 操作的结果集</param>
        /// <returns></returns>
        public async Task<List<T>> getByIn<S>(List<S> list, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().In<S>(list).OrderByIF(isOrderBy, orderBy, orderByType).ToListAsync();
        }

        /// <summary>
        /// 根据指定列 In 查询
        /// </summary>
        /// <typeparam name="S">指定列的类型</typeparam>
        /// <param name="column">指定列</param>
        /// <param name="list">指定列 In 操作 的结果集</param>
        /// <returns></returns>
        public async Task<List<T>> getByIn<S>(Expression<Func<T, object>> column, List<S> list, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().In<S>(column, list).OrderByIF(isOrderBy, orderBy, orderByType).ToListAsync();
        }

        /// <summary>
        /// 根据指定列 Not In (!Contain)查询
        /// </summary>
        /// <typeparam name="S">指定列类型</typeparam>
        /// <param name="list">Not In的结果集</param>
        /// <param name="field">指定列</param>
        /// <returns></returns>
        public async Task<List<T>> getByNotIn<S>(List<S> list, object field, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().Where(t => !SqlFunc.ContainsArray(list, field)).OrderByIF(isOrderBy, orderBy, orderByType).ToListAsync();
        }

        /// <summary>
        /// 根据条件 查询
        /// </summary>
        /// <param name="where">条件</param>
        /// <returns></returns>
        public async Task<List<T>> getByWhere(Expression<Func<T, bool>> where, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().Where(where).OrderByIF(isOrderBy, orderBy, orderByType).ToListAsync();
        }

        /// <summary>
        /// 单个条件 根据 isWhere 判断 是否使用此条件进行查询
        /// </summary>
        /// <param name="isWhere">判断是否使用此查询条件的条件</param>
        /// <param name="where">查询条件</param>
        /// <returns></returns>
        public async Task<List<T>> getByWhereIF(bool isWhere, Expression<Func<T, bool>> where, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().WhereIF(isWhere, where).OrderByIF(isOrderBy, orderBy, orderByType).ToListAsync();
        }

        /// <summary>
        /// 多个条件 根据 wheres.value  判断是否使用 此 wheres.key 的条件
        /// </summary>
        /// <param name="wheres">查询条件</param>
        /// <returns></returns>
        public async Task<List<T>> getByWhereIF(Dictionary<Expression<Func<T, bool>>, bool> wheres, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            var able = context.db.Queryable<T>();
            foreach (var item in wheres)
            {
                able.WhereIF(item.Value, item.Key);
            }
            return await able.OrderByIF(isOrderBy, orderBy, orderByType).ToListAsync();
        }

        /// <summary>
        /// 查询 指定列的值 在 start至end 之间的数据
        /// </summary>
        /// <param name="value">指定类</param>
        /// <param name="start">开始</param>
        /// <param name="end">结束</param>
        /// <returns></returns>
        public async Task<List<T>> getByBetween(object value, object start, object end, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().Where(it => SqlFunc.Between(value, start, end)).OrderByIF(isOrderBy, orderBy, orderByType).ToListAsync();
        }

        /// <summary>
        /// 判断是否存在这条记录
        /// </summary>
        /// <param name="where">条件</param>
        /// <returns></returns>
        public async Task<bool> getIsAny(Expression<Func<T, bool>> where)
        {
            return await context.db.Queryable<T>().AnyAsync(where);
        }

        /// <summary>
        /// 单表分页查询
        /// </summary>
        /// <typeparam name="T">要查询的表</typeparam>
        /// <param name="pagination">分页参数</param>
        /// <param name="isWhere">是否需要条件查询</param>
        /// <param name="whereExp">查询条件</param>
        /// <param name="isOrderBy">是否需要排序条件</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        public async Task<List<T>> getPageList(Pagination pagination, bool isWhere = false, Expression<Func<T, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            RefAsync<int> totalNumber = 0;
            var result = await context.db.Queryable<T>().WhereIF(isWhere, whereExp).OrderByIF(isOrderBy, orderBy, orderByType).ToPageListAsync(pagination.PageIndex, pagination.PageSize, totalNumber);
            pagination.TotalCount = totalNumber;
            return result;
        }

        /// <summary>
        /// 两表查询，
        /// </summary>
        /// <typeparam name="T1">左表</typeparam>
        /// <typeparam name="T2">右表</typeparam>
        /// <param name="joinExp">联表方式，联表字段（主外键关系）</param>
        /// <param name="selectExp">联表查询的结果</param>
        /// <param name="isWhere">是否需要查询条件</param>
        /// <param name="whereExp">条件查询</param>
        /// <param name="isOrderBy">是否需要排序</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        public async Task<dynamic> getJoinList<T1, T2>(Expression<Func<T1, T2, JoinQueryInfos>> joinExp, Expression<Func<T1, T2, dynamic>> selectExp, bool isWhere = false, Expression<Func<T1, T2, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T1, T2, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {

            return await context.db.Queryable<T1, T2>(joinExp).WhereIF(isWhere, whereExp)
                .OrderByIF(isOrderBy, orderBy, orderByType).Select(selectExp).ToListAsync();
        }

        /// <summary>
        /// 两表 分页查询，
        /// </summary>
        /// <typeparam name="T1">左表</typeparam>
        /// <typeparam name="T2">右表</typeparam>
        /// <param name="pagination">分页参数</param>
        /// <param name="joinExp">联表方式，联表字段（主外键关系）</param>
        /// <param name="selectExp">联表查询的结果</param>
        /// <param name="isWhere">是否需要查询条件</param>
        /// <param name="whereExp">条件查询</param>
        /// <param name="isOrderBy">是否需要排序</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        public async Task<dynamic> getJoinPageList<T1, T2>(Pagination pagination, Expression<Func<T1, T2, JoinQueryInfos>> joinExp, Expression<Func<T1, T2, dynamic>> selectExp, bool isWhere = false, Expression<Func<T1, T2, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T1, T2, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {

            return await context.db.Queryable<T1, T2>(joinExp).WhereIF(isWhere, whereExp)
                .OrderByIF(isOrderBy, orderBy, orderByType).Select(selectExp).ToPageListAsync(pagination.PageIndex, pagination.PageSize, pagination.TotalCount);
        }

        /// <summary>
        /// 三表连接 查询
        /// </summary>
        /// <typeparam name="T1">表1</typeparam>
        /// <typeparam name="T2">表2</typeparam>
        /// <typeparam name="T3">表3</typeparam>
        /// <param name="joinExp">联表方式，联表字段（主外键关系）</param>
        /// <param name="selectExp">联表查询的结果</param>
        /// <param name="isWhere">是否需要查询条件</param>
        /// <param name="whereExp">查询条件</param>
        /// <param name="isOrderBy">是否需要排序条件</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        public async Task<dynamic> getJoinList<T1, T2, T3>(Expression<Func<T1, T2, T3, JoinQueryInfos>> joinExp, Expression<Func<T1, T2, T3, dynamic>> selectExp, bool isWhere = false, Expression<Func<T1, T2, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T1, T2, T3, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T1, T2, T3>(joinExp).WhereIF(isWhere, whereExp).OrderByIF(isOrderBy, orderBy, orderByType).Select(selectExp).ToListAsync();
        }

        /// <summary>
        /// 三表连接 分页 查询
        /// </summary>
        /// <typeparam name="T1">表1</typeparam>
        /// <typeparam name="T2">表2</typeparam>
        /// <typeparam name="T3">表3</typeparam>
        /// <param name="pagination">分页参数</param>
        /// <param name="joinExp">联表方式，联表字段（主外键关系）</param>
        /// <param name="selectExp">联表查询的结果</param>
        /// <param name="isWhere">是否需要查询条件</param>
        /// <param name="whereExp">查询条件</param>
        /// <param name="isOrderBy">是否需要排序条件</param>
        /// <param name="orderBy">排序条件</param>
        /// <param name="orderByType">排序类型（Asc、Desc）</param>
        /// <returns></returns>
        public async Task<dynamic> getJoinList<T1, T2, T3>(Pagination pagination, Expression<Func<T1, T2, T3, JoinQueryInfos>> joinExp, Expression<Func<T1, T2, T3, dynamic>> selectExp, bool isWhere = false, Expression<Func<T1, T2, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T1, T2, T3, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T1, T2, T3>(joinExp).WhereIF(isWhere, whereExp).OrderByIF(isOrderBy, orderBy, orderByType)
                .Select(selectExp).ToPageListAsync(pagination.PageIndex, pagination.PageSize, pagination.TotalCount);
        }

        /// <summary>
        /// 执行查询sql语句 ，返回数据集
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <returns></returns>
        public async Task<List<T>> getListBySql(string sql)
        {
            return await context.db.SqlQueryable<T>(sql).ToListAsync();
        }

        /// <summary>
        /// 执行非查询sql语句，返回操作是否成功
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">参数化</param>
        /// <returns></returns>
        public async Task<bool> ExecuteCommandSql(string sql, List<SugarParameter> parameters)
        {
            return await context.db.Ado.ExecuteCommandAsync(sql, parameters) > 0;
        }

        /// <summary>
        /// 执行查询sql语句，返回查询的结果集
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">参数化</param>
        /// <returns></returns>
        public async Task<List<T>> getListBySqlQuery(string sql, List<SugarParameter> parameters)
        {
            return await context.db.Ado.SqlQueryAsync<T>(sql, parameters);
        }


        /// <summary>
        ///  执行查询sql语句，返回查询的DataTable
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">参数化</param>
        /// <returns></returns>
        public async Task<DataTable> getDataTable(string sql, List<SugarParameter> parameters)
        {
            return await context.db.Ado.GetDataTableAsync(sql, parameters);
        }

        /// <summary>
        /// 执行查询sql语句，返回 第一行第一列
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">参数化</param>
        /// <returns></returns>
        public async Task<object> getScalar(string sql, List<SugarParameter> parameters)
        {
            return await context.db.Ado.GetScalarAsync(sql, parameters);
        }





        #endregion

        #region 其他


        /// <summary>
        /// 使用存储过程，返回结果集
        /// </summary>
        /// <param name="procedureName">存储过程名称 </param>
        /// <param name="parameters">参数，支持 output</param>
        /// <returns></returns>
        public async Task<DataTable> UseStoredProcedure(string procedureName, List<SugarParameter> parameters)
        {
            return await context.db.Ado.UseStoredProcedure().GetDataTableAsync(procedureName, parameters);
        }

        /// <summary>
        /// 使用事务 ，无返回值
        /// </summary>
        /// <param name="action">执行动作</param>
        /// <param name="errorCallBack">错误回调</param>
        public async Task<DbResult<bool>> UseTran(Func<Task> func, Action<Exception> errorCallBack)
        {
            return await context.db.Ado.UseTranAsync(func, errorCallBack); ;
        }

        /// <summary>
        /// 使用事务，有返回值
        /// </summary>
        /// <typeparam name="S">返回值类型</typeparam>
        /// <param name="func">执行动作</param>
        /// <param name="errorCallBack">错误回调</param>
        public async Task<DbResult<S>> UseTran<S>(Func<Task<S>> func, Action<Exception> errorCallBack)
        {
            return await context.db.Ado.UseTranAsync(func, errorCallBack);
        }

        #endregion
    }

}
复制代码

5、调用仓储方法

5.1 创建方法接口

复制代码
using BoZhon.Data.SqlSugar.Repository;
using BoZhon.Entity.BaseManage;
using BoZhon.Model.Param.BaseManage;
using BoZhon.Util.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BoZhon.IService.BaseManage
{
    ///<summary>
    ///系统日志表
    ///</summary>
    public interface base_logIServer : IBaseRepository<base_logEntity>
    {
        /// <summary>
        /// 根据主键获取数据
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        Task<base_logEntity> FindEntity(string Id);

        /// <summary>
        /// 根据条件获取信息
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        Task<List<base_logEntity>> FindList(base_logParam param);


        /// <summary>
        /// 根据条件获取分页信息
        /// </summary>
        /// <param name="param"></param>
        /// <param name="pagination"></param>
        /// <returns></returns>
        Task<List<base_logEntity>> FindPageList(base_logParam param, Pagination pagination);

        /// <summary>
        /// 新增数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Task<bool> InsetEntity(base_logEntity entity);

        /// <summary>
        /// 修改数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Task<bool> UpdateEntity(base_logEntity entity);

        /// <summary>
        /// 根据主键删除信息
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        Task<bool> DeleteEntityById(string Id);

        /// <summary>
        /// 根据多个主键删除信息
        /// </summary>
        /// <param name="Ids"></param>
        /// <returns></returns>
        Task<bool> DeleteEntityByIds(List<string> Ids);
    }
复制代码

5.2 实现接口

复制代码
using BoZhon.Data.SqlSugar.DbContext;
using BoZhon.Data.SqlSugar.Repository;
using BoZhon.Entity.BaseManage;
using BoZhon.IService.BaseManage;
using BoZhon.Model.Param.BaseManage;
using BoZhon.Util.Extension;
using BoZhon.Util.Model;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace BoZhon.Service.BaseManage
{
    ///<summary>
    ///系统日志表
    ///</summary>
    public class base_logServer : BaseRepository<base_logEntity>, base_logIServer
    {
        #region 获取数据

        /// <summary>
        /// 根据主键获取信息
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public async Task<base_logEntity> FindEntity(string Id)
        {
            return await this.getByPrimaryKey(Id);
        }

        /// <summary>
        /// 根据条件查询信息
        /// </summary>
        /// <param name="param">条件实体</param>
        /// <returns></returns>
        public async Task<List<base_logEntity>> FindList(base_logParam param)
        {
            var expression = ListFilter(param);
            var list = await this.getByWhere(expression);
            return list;
        }

        /// <summary>
        /// 根据条件查询实体数据信息
        /// </summary>
        /// <param name="param">条件实体</param>
        /// <param name="pagination">分页信息</param>
        /// <returns></returns>
        public async Task<List<base_logEntity>> FindPageList(base_logParam param, Pagination pagination)
        {
            var expression = ListFilter(param);
            var list = await this.getPageList(pagination, true, expression);
            return list;
        }

        #endregion

        #region 提交数据

        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public async Task<bool> DeleteEntityById(string Id)
        {
            return await this.Delete(Id);
        }

        /// <summary>
        /// 根据多个主键删除数据
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public async Task<bool> DeleteEntityByIds(List<string> ids)
        {
            string[] idsArray = ids.ToArray();
            return await this.Delete(idsArray);
        }

        /// <summary>
        /// 新增数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task<bool> InsetEntity(base_logEntity entity)
        {
            return await this.Add(entity);
        }

        /// <summary>
        /// 修改数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task<bool> UpdateEntity(base_logEntity entity)
        {
            return await this.UpdateNotNullColumns(entity, true, false, false);
        }

        #endregion

        #region 私有方法

        /// <summary>
        /// 查询条件组合
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private Expression<Func<base_logEntity, bool>> ListFilter(base_logParam param)
        {
            var expression = LinqExtensions.True<base_logEntity>();
            if (param != null)
            {
                if (!param.LogID.IsEmpty())
                {
                    expression = expression.And(t => t.LogID.Equals(param.LogID));
                }
                if (!param.FunctionName.IsEmpty())
                {
                    expression = expression.And(t => t.FunctionName.Equals(param.FunctionName));
                }
                if (!param.ParamText.IsEmpty())
                {
                    expression = expression.And(t => t.ParamText.Equals(param.ParamText));
                }
                if (!param.CreateUserId.IsEmpty())
                {
                    expression = expression.And(t => t.CreateUserId.Equals(param.CreateUserId));
                }
                if (!param.LocalIP.IsEmpty())
                {
                    expression = expression.And(t => t.LocalIP.Equals(param.LocalIP));
                }
                if (!param.ClassName.IsEmpty())
                {
                    expression = expression.And(t => t.ClassName.Equals(param.ClassName));
                }
            }
            return expression;
        }

        #endregion


    }
}
复制代码

 

posted @   搬砖工具人  阅读(845)  评论(0)  编辑  收藏  举报
相关博文：
· 十、数组中的响应式方法
· 二十五、Fragment（动态添加FragMent）
· .NET6 WebAPI开发练习—使用SqlSugar连接Mysql
· SqlSugar-C#版（一）_安装与基础使用
· SqlSugar DbContext
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！
点击右上角即可分享
微信分享提示