SqlSugar泛型封裝

1、下載安裝包

.NetFramework

 

 

.NetCore

 

 

2、項目為 NetCore 采用 倉儲服務模式

Repository+Service

 

IDbContext

 public interface IDbContext
    {
        /// <summary>
        /// 操作數據庫對象
        /// </summary>
        public SqlSugarClient db { get; }

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


        /// <summary>
        /// 創建表
        /// </summary>
        /// <param name="Backup">是否備份</param>
        /// <param name="StringDefaultLength">string類型映射的長度</param>
        public void CreateAllTable(bool Backup = false, int StringDefaultLength = 50);

    }

 

AppDbContext

/// <summary>
    /// 數據庫上下文
    /// </summary>
    public class AppDbContext : IDbContext
    {
        private readonly IConfiguration Configuration;
        public AppDbContext(IConfiguration configuration)
        {
            Configuration = configuration;
            //打印日志
            db.Aop.OnLogExecuting = (sql, paramster) =>
            {
                Console.WriteLine(sql + $"\r\n" +
                    $"{db.Utilities.SerializeObject(paramster.ToDictionary(it => it.ParameterName, it => it.Value))} \r\n");

            };
        }

        public AppDbContext()
        {

        }
        public SimpleClient<StudentInfo> Simple { get { return new SimpleClient<StudentInfo>(db); } }

        /// <summary>
        /// 操作數據庫對象
        /// </summary>
        public SqlSugarClient db
        {
            get
            {
                return new SqlSugarClient(new ConnectionConfig()
                {
                    ConnectionString = Configuration.GetConnectionString("DefaultConnection")//連接字符串
                    ?? "server=.;database=StudentDb;uid=sa;pwd=123456;",
                    DbType = DbType.SqlServer,//數據庫類型
                    IsAutoCloseConnection = true,//自動釋放數據務，如果存在事務，在事務結束后釋放
                    InitKeyType = InitKeyType.Attribute,//從實體特性中讀取主鍵自增列信息
                });
            }
        }

       

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

        }

    }

 

IBaseRepository

IBaseRepository

public interface IBaseRepository<T> where T : class, new()
    {
        #region Add
        /// <summary>
        /// 增加單條數據
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <returns>操作是否成功</returns>
        public Task<bool> Add(T model);

        /// <summary>
        /// 增加多條數據
        /// </summary>
        /// <param name="list">實體集合</param>
        /// <returns>操作是否成功</returns>
        public Task<bool> AddRange(List<T> list);


        /// <summary>
        /// 添加單條數據，並返回 自增列
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <returns></returns>
        public Task<bool> AddReturnIdentity(T model);

        /// <summary>
        /// 增加單條數據 ，並返回 實體
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <returns></returns>
        public Task<T> AddReturnEntity(T model);


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


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


        #endregion

        #region Delete

        /// <summary>
        /// 根據主鍵刪除，並返回操作是否成功
        /// </summary>
        /// <typeparam name="S">主鍵的類型</typeparam>
        /// <param name="key">主鍵</param>
        /// <returns></returns>
        public Task<bool> Delete<S>(S key);


        /// <summary>
        /// 根據主鍵刪除，並返回操作是否成功
        /// </summary>
        /// <typeparam name="S">主鍵類型</typeparam>
        /// <param name="keys">主鍵</param>
        /// <returns></returns>
        public Task<bool> DeleteRange<S>(params S[] keys);


        /// <summary>
        /// 根據條件刪除，並返回操作是否成功
        /// </summary>
        /// <param name="where">條件</param>
        /// <returns></returns>
        public Task<bool> DeleteWhere(Expression<Func<T, bool>> where);


        #endregion

        #region Update

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


        /// <summary>
        /// 根據主鍵更新，返回操作是否成功
        /// </summary>
        /// <param name="list">實體集合</param>
        /// <returns></returns>
        public Task<bool> UpdateRange(List<T> list);


        /// <summary>
        /// 根據指定 列條件 更新 ，並返回操作是否成功
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <param name="expression">列條件 例如： t=>t.id>5 </param>
        public Task<bool> Update(T model, Expression<Func<T, object>> expression);


        /// <summary>
        /// 根據主鍵，更新指定列,返回操作是否成功
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <param name="columns">要更新的列</param>
        /// <returns></returns>
        public Task<bool> UpdateColumns(T model, params string[] columns);


        /// <summary>
        /// 根據主鍵，更新指定列,返回操作是否成功
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <param name="columns">要更新的列</param>
        /// <returns></returns>
        public Task<bool> UpdateColumns(T model, Expression<Func<T, object>> columns);


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


        /// <summary>
        /// 根據主鍵 ， 忽略更新指定列，返回操作是否成功
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <param name="columns">不更新的 忽略列</param>
        /// <returns></returns>
        public 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>
        public 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>
        public Task<bool> UpdateIF(T model, Dictionary<Expression<Func<T, object>>, bool> dic);


        #endregion

        #region Query

        /// <summary>
        /// 查詢所有數據
        /// </summary>
        /// <returns></returns>
        public 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>
        public 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>
        public 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> 
        public 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>
        public Task<T> getByPrimaryKey(object pkValue);


        /// <summary>
        /// 根據條件獲取 單條數據 
        /// </summary>
        /// <param name="where">條件</param>
        /// <returns></returns>
        public Task<T> getFirstOrDefault(Expression<Func<T, bool>> where);


        /// <summary>
        /// 根據主鍵 In  查詢
        /// </summary>
        /// <typeparam name="S">主鍵的類型</typeparam>
        /// <param name="list">主鍵 In 操作的結果集</param>
        /// <returns></returns>
        public 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>
        public 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>
        public 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>
        public 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>
        public 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>
        public 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>
        public 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>
        public Task<bool> getIsAny(Expression<Func<T, bool>> where);


        /// <summary>
        /// 單表分頁查詢
        /// </summary>
        /// <typeparam name="T">要查詢的表</typeparam>
        /// <param name="pageIndex">頁碼</param>
        /// <param name="pageSize">頁面容量</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 Task<List<T>> getPageList<T>(int pageIndex, int pageSize, 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>
        public 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="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 Task<dynamic> getJoinPageList<T1, T2>(int pageIndex, int pageSize, 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>
        public 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="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 Task<dynamic> getJoinList<T1, T2, T3>(int pageIndex, int pageSize, 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>
        public Task<List<T>> getListBySql(string sql);


        /// <summary>
        /// 執行非查詢sql語句，返回操作是否成功
        /// </summary>
        /// <param name="sql">sql語句</param>
        /// <param name="parameters">參數化</param>
        /// <returns></returns>
        public Task<bool> ExecuteCommandSql(string sql, params SugarParameter[] parameters);


        /// <summary>
        /// 執行查詢sql語句，返回查詢的結果集
        /// </summary>
        /// <param name="sql">sql語句</param>
        /// <param name="parameters">參數化</param>
        /// <returns></returns>
        public Task<List<T>> getListBySqlQuery(string sql, params SugarParameter[] parameters);


        /// <summary>
        /// 執行查詢sql語句，返回 第一行第一列
        /// </summary>
        /// <param name="sql">sql語句</param>
        /// <param name="parameters">參數化</param>
        /// <returns></returns>
        public Task<object> getScalar(string sql, params SugarParameter[] parameters);



        #endregion

        #region Other


        /// <summary>
        /// 使用存儲過程，返回結果集
        /// </summary>
        /// <param name="procedureName">存儲過程名稱 </param>
        /// <param name="parameters">參數，支持 output</param>
        /// <returns></returns>
        public Task<DataTable> UseStoredProcedure(string procedureName, params SugarParameter[] parameters);


        /// <summary>
        /// 使用事務 ，無返回值
        /// </summary>
        /// <param name="action">執行動作</param>
        /// <param name="errorCallBack">錯誤回調</param>
        public Task<DbResult<bool>> UseTran(Action action, Action<Exception> errorCallBack);


        /// <summary>
        /// 使用事務，有返回值
        /// </summary>
        /// <typeparam name="S">返回值類型</typeparam>
        /// <param name="func">執行動作</param>
        /// <param name="errorCallBack">錯誤回調</param>
        public Task<DbResult<S>> UseTran<S>(Func<S> func, Action<Exception> errorCallBack);


        #endregion
    }

 

BaseRepository

 public class BaseRepository<T> : IBaseRepository<T> where T : class, new()
    {
        private readonly IDbContext context;
        public BaseRepository(IDbContext dbContext)
        {
            context = dbContext;
        }

        #region Add
        /// <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 Delete

        /// <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 Update

        /// <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>()
                .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 Query

        /// <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="pageIndex">頁碼</param>
        /// <param name="pageSize">頁面容量</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<T>(int pageIndex, int pageSize, bool isWhere = false, Expression<Func<T, bool>> whereExp = null, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return await context.db.Queryable<T>().WhereIF(isWhere, whereExp).OrderByIF(isOrderBy, orderBy, orderByType).ToPageListAsync(pageIndex, pageSize);
        }

        /// <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="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>(int pageIndex, int pageSize, 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(pageIndex, pageSize);
        }

        /// <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="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>(int pageIndex, int pageSize, 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(pageIndex, pageSize);
        }

        /// <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, params 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, params SugarParameter[] parameters)
        {
            return await context.db.Ado.SqlQueryAsync<T>(sql, parameters);
        }

        /// <summary>
        /// 執行查詢sql語句，返回 第一行第一列
        /// </summary>
        /// <param name="sql">sql語句</param>
        /// <param name="parameters">參數化</param>
        /// <returns></returns>
        public async Task<object> getScalar(string sql, params SugarParameter[] parameters)
        {
            return await context.db.Ado.GetScalarAsync(sql, parameters);
        }


        #endregion

        #region Other


        /// <summary>
        /// 使用存儲過程，返回結果集
        /// </summary>
        /// <param name="procedureName">存儲過程名稱 </param>
        /// <param name="parameters">參數，支持 output</param>
        /// <returns></returns>
        public async Task<DataTable> UseStoredProcedure(string procedureName, params 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(Action action, Action<Exception> errorCallBack)
        {
            return await context.db.Ado.UseTranAsync(action, errorCallBack); ;
        }

        /// <summary>
        /// 使用事務，有返回值
        /// </summary>
        /// <typeparam name="S">返回值類型</typeparam>
        /// <param name="func">執行動作</param>
        /// <param name="errorCallBack">錯誤回調</param>
        public async Task<DbResult<S>> UseTran<S>(Func<S> func, Action<Exception> errorCallBack)
        {
            return await context.db.Ado.UseTranAsync(func, errorCallBack);
        }

        #endregion



    }

 

IStudentInfoRepository

public interface IStudentInfoRepository : IBaseRepository<StudentInfo>
    {

    }

 

StudentRepository

public class StudentInfoRepository : BaseRepository<StudentInfo>, IStudentInfoRepository
    {
        private readonly IDbContext context;
        public StudentInfoRepository(IDbContext dbContext)
            : base(dbContext)
        {
            context = dbContext;

        }

    }

 

IBaseService

public interface IBaseService<T> where T : class, new()
    {
        #region Add
        /// <summary>
        /// 增加單條數據
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <returns>操作是否成功</returns>
        public Task<bool> Add(T model);

        /// <summary>
        /// 增加多條數據
        /// </summary>
        /// <param name="list">實體集合</param>
        /// <returns>操作是否成功</returns>
        public Task<bool> AddRange(List<T> list);


        /// <summary>
        /// 添加單條數據，並返回 自增列
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <returns></returns>
        public Task<bool> AddReturnIdentity(T model);

        /// <summary>
        /// 增加單條數據 ，並返回 實體
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <returns></returns>
        public Task<T> AddReturnEntity(T model);


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


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


        #endregion

        #region Delete

        /// <summary>
        /// 根據主鍵刪除，並返回操作是否成功
        /// </summary>
        /// <typeparam name="S">主鍵的類型</typeparam>
        /// <param name="key">主鍵</param>
        /// <returns></returns>
        public Task<bool> Delete<S>(S key);


        /// <summary>
        /// 根據主鍵刪除，並返回操作是否成功
        /// </summary>
        /// <typeparam name="S">主鍵類型</typeparam>
        /// <param name="keys">主鍵</param>
        /// <returns></returns>
        public Task<bool> DeleteRange<S>(params S[] keys);


        /// <summary>
        /// 根據條件刪除，並返回操作是否成功
        /// </summary>
        /// <param name="where">條件</param>
        /// <returns></returns>
        public Task<bool> DeleteWhere(Expression<Func<T, bool>> where);


        #endregion

        #region Update

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


        /// <summary>
        /// 根據主鍵更新，返回操作是否成功
        /// </summary>
        /// <param name="list">實體集合</param>
        /// <returns></returns>
        public Task<bool> UpdateRange(List<T> list);


        /// <summary>
        /// 根據指定 列條件 更新 ，並返回操作是否成功
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <param name="expression">列條件 例如： t=>t.id>5 </param>
        public Task<bool> Update(T model, Expression<Func<T, object>> expression);


        /// <summary>
        /// 根據主鍵，更新指定列,返回操作是否成功
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <param name="columns">要更新的列</param>
        /// <returns></returns>
        public Task<bool> UpdateColumns(T model, params string[] columns);


        /// <summary>
        /// 根據主鍵，更新指定列,返回操作是否成功
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <param name="columns">要更新的列</param>
        /// <returns></returns>
        public Task<bool> UpdateColumns(T model, Expression<Func<T, object>> columns);


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


        /// <summary>
        /// 根據主鍵 ， 忽略更新指定列，返回操作是否成功
        /// </summary>
        /// <param name="model">實體對象</param>
        /// <param name="columns">不更新的 忽略列</param>
        /// <returns></returns>
        public 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>
        public 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>
        public Task<bool> UpdateIF(T model, Dictionary<Expression<Func<T, object>>, bool> dic);


        #endregion

        #region Query

        /// <summary>
        /// 查詢所有數據
        /// </summary>
        /// <returns></returns>
        public 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>
        public 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>
        public 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> 
        public 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>
        public Task<T> getByPrimaryKey(object pkValue);


        /// <summary>
        /// 根據條件獲取 單條數據 
        /// </summary>
        /// <param name="where">條件</param>
        /// <returns></returns>
        public Task<T> getFirstOrDefault(Expression<Func<T, bool>> where);


        /// <summary>
        /// 根據主鍵 In  查詢
        /// </summary>
        /// <typeparam name="S">主鍵的類型</typeparam>
        /// <param name="list">主鍵 In 操作的結果集</param>
        /// <returns></returns>
        public 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>
        public 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>
        public 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>
        public 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>
        public 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>
        public 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>
        public 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>
        public Task<bool> getIsAny(Expression<Func<T, bool>> where);


        /// <summary>
        /// 單表分頁查詢
        /// </summary>
        /// <typeparam name="T">要查詢的表</typeparam>
        /// <param name="pageIndex">頁碼</param>
        /// <param name="pageSize">頁面容量</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 Task<List<T>> getPageList<T>(int pageIndex, int pageSize, 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>
        public 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="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 Task<dynamic> getJoinPageList<T1, T2>(int pageIndex, int pageSize, 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>
        public 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="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 Task<dynamic> getJoinList<T1, T2, T3>(int pageIndex, int pageSize, 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>
        public Task<List<T>> getListBySql(string sql);


        /// <summary>
        /// 執行非查詢sql語句，返回操作是否成功
        /// </summary>
        /// <param name="sql">sql語句</param>
        /// <param name="parameters">參數化</param>
        /// <returns></returns>
        public Task<bool> ExecuteCommandSql(string sql, params SugarParameter[] parameters);


        /// <summary>
        /// 執行查詢sql語句，返回查詢的結果集
        /// </summary>
        /// <param name="sql">sql語句</param>
        /// <param name="parameters">參數化</param>
        /// <returns></returns>
        public Task<List<T>> getListBySqlQuery(string sql, params SugarParameter[] parameters);


        /// <summary>
        /// 執行查詢sql語句，返回 第一行第一列
        /// </summary>
        /// <param name="sql">sql語句</param>
        /// <param name="parameters">參數化</param>
        /// <returns></returns>
        public Task<object> getScalar(string sql, params SugarParameter[] parameters);



        #endregion

        #region Other


        /// <summary>
        /// 使用存儲過程，返回結果集
        /// </summary>
        /// <param name="procedureName">存儲過程名稱 </param>
        /// <param name="parameters">參數，支持 output</param>
        /// <returns></returns>
        public Task<DataTable> UseStoredProcedure(string procedureName, params SugarParameter[] parameters);


        /// <summary>
        /// 使用事務 ，無返回值
        /// </summary>
        /// <param name="action">執行動作</param>
        /// <param name="errorCallBack">錯誤回調</param>
        public Task<DbResult<bool>> UseTran(Action action, Action<Exception> errorCallBack);


        /// <summary>
        /// 使用事務，有返回值
        /// </summary>
        /// <typeparam name="S">返回值類型</typeparam>
        /// <param name="func">執行動作</param>
        /// <param name="errorCallBack">錯誤回調</param>
        public Task<DbResult<S>> UseTran<S>(Func<S> func, Action<Exception> errorCallBack);


        #endregion
    }

 

BaseService

public class BaseService<T> : IBaseService<T> where T : class, new()
    {
        private readonly IBaseRepository<T> _baseRepository;
        public BaseService(IBaseRepository<T> baseRepository)
        {
            _baseRepository = baseRepository;
        }
        public Task<bool> Add(T model)
        {
            return _baseRepository.Add(model);
        }

        public Task<bool> AddColumns(T model, params string[] columns)
        {
            return _baseRepository.AddColumns(model, columns);
        }

        public Task<bool> AddColumnsByIgnoreColumns(T model, params string[] IgnoreColumns)
        {
            return _baseRepository.AddColumnsByIgnoreColumns(model, IgnoreColumns);
        }

        public Task<bool> AddRange(List<T> list)
        {
            return _baseRepository.AddRange(list);
        }

        public Task<T> AddReturnEntity(T model)
        {
            return _baseRepository.AddReturnEntity(model);
        }

        public Task<bool> AddReturnIdentity(T model)
        {
            return _baseRepository.AddReturnIdentity(model);
        }

        public Task<bool> Delete<S>(S key)
        {
            return _baseRepository.Delete<S>(key);
        }

        public Task<bool> DeleteRange<S>(params S[] keys)
        {
            return _baseRepository.DeleteRange<S>(keys);
        }

        public Task<bool> DeleteWhere(Expression<Func<T, bool>> where)
        {
            return _baseRepository.DeleteWhere(where);
        }

        public Task<bool> ExecuteCommandSql(string sql, params SugarParameter[] parameters)
        {
            return _baseRepository.ExecuteCommandSql(sql, parameters);
        }

        public Task<List<T>> getAll(bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return _baseRepository.getAll(isOrderBy, orderBy, orderByType);
        }

        public Task<List<T>> getByBetween(object value, object start, object end, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return _baseRepository.getByBetween(value, start, end, isOrderBy, orderBy, orderByType);
        }

        public Task<List<T>> getByIn<S>(List<S> list, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return _baseRepository.getByIn<S>(list, isOrderBy, orderBy, orderByType);
        }

        public 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 _baseRepository.getByIn<S>(column, list, isOrderBy, orderBy, orderByType);
        }

        public Task<List<T>> getByNotIn<S>(List<S> list, object field, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return _baseRepository.getByNotIn<S>(list, field, isOrderBy, orderBy, orderByType);
        }

        public Task<T> getByPrimaryKey(object pkValue)
        {
            return _baseRepository.getByPrimaryKey(pkValue);
        }

        public Task<List<T>> getByWhere(Expression<Func<T, bool>> where, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return _baseRepository.getByWhere(where, isOrderBy, orderBy, orderByType);
        }

        public 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 _baseRepository.getByWhereIF(isWhere, where, isOrderBy, orderBy, orderByType);
        }

        public Task<List<T>> getByWhereIF(Dictionary<Expression<Func<T, bool>>, bool> wheres, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return _baseRepository.getByWhereIF(wheres, isOrderBy, orderBy, orderByType);
        }

        public Task<T> getFirstOrDefault(Expression<Func<T, bool>> where)
        {
            return _baseRepository.getFirstOrDefault(where);
        }

        public Task<bool> getIsAny(Expression<Func<T, bool>> where)
        {
            return _baseRepository.getIsAny(where);
        }

        public 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 _baseRepository.getJoinList<T1, T2>(joinExp, selectExp, isWhere, whereExp, isOrderBy, orderBy, orderByType);
        }

        public 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 _baseRepository.getJoinList<T1, T2, T3>(joinExp, selectExp, isWhere, whereExp, isOrderBy, orderBy, orderByType);
        }

        public Task<dynamic> getJoinList<T1, T2, T3>(int pageIndex, int pageSize, 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 _baseRepository.getJoinList<T1, T2, T3>(pageIndex, pageSize, joinExp, selectExp, isWhere, whereExp, isOrderBy, orderBy, orderByType); ;
        }

        public Task<dynamic> getJoinPageList<T1, T2>(int pageIndex, int pageSize, 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 _baseRepository.getJoinPageList<T1, T2>(pageIndex, pageSize, joinExp, selectExp, isWhere, whereExp, isOrderBy, orderBy, orderByType);
        }

        public Task<List<T>> getListBySql(string sql)
        {
            return _baseRepository.getListBySql(sql);
        }

        public Task<List<T>> getListBySqlQuery(string sql, params SugarParameter[] parameters)
        {
            return _baseRepository.getListBySqlQuery(sql, parameters);
        }

        public Task<List<T>> getPageList(int skip, int take, Expression<Func<T, bool>> whereExp, Expression<Func<T, object>> orderBy, OrderByType orderByType = OrderByType.Asc)
        {
            return _baseRepository.getPageList(skip, take, whereExp, orderBy, orderByType);
        }

        public Task<List<T1>> getPageList<T1>(int pageIndex, int pageSize, bool isWhere = false, Expression<Func<T1, bool>> whereExp = default, bool isOrderBy = false, Expression<Func<T1, object>> orderBy = default, OrderByType orderByType = OrderByType.Asc)
        {
            return _baseRepository.getPageList<T1>(pageIndex, pageSize, isWhere, whereExp, isOrderBy, orderBy, orderByType);
        }

        public Task<object> getScalar(string sql, params SugarParameter[] parameters)
        {
            return _baseRepository.getScalar(sql, parameters);
        }

        public Task<List<T>> getTakeList(int num, bool isOrderBy = false, Expression<Func<T, object>> orderBy = null, OrderByType orderByType = OrderByType.Asc)
        {
            return _baseRepository.getTakeList(num, isOrderBy, orderBy, orderByType);
        }

        public 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 _baseRepository.getTakeList(where, num, isOrderBy, orderBy, orderByType);
        }

        public Task<bool> Update(T model)
        {
            return _baseRepository.Update(model);
        }

        public Task<bool> Update(T model, Expression<Func<T, object>> expression)
        {
            return _baseRepository.Update(model, expression);
        }

        public Task<bool> UpdateColumns(T model, params string[] columns)
        {
            return _baseRepository.UpdateColumns(model, columns);
        }

        public Task<bool> UpdateColumns(T model, Expression<Func<T, object>> columns)
        {
            return _baseRepository.UpdateColumns(model, columns);
        }

        public Task<bool> UpdateColumnsByIgnoreColumns(T model, params string[] columns)
        {
            return _baseRepository.UpdateColumnsByIgnoreColumns(model, columns);
        }

        public Task<bool> UpdateColumnsByIgnoreColumns(T model, Expression<Func<T, object>> columns)
        {
            return _baseRepository.UpdateColumnsByIgnoreColumns(model, columns);
        }

        public Task<bool> UpdateIF(T model, Dictionary<Expression<Func<T, object>>, bool> dic)
        {
            return _baseRepository.UpdateIF(model, dic);
        }

        public Task<bool> UpdateNotNullColumns(T model, bool ignoreAllNullColumns, bool isOffIdentity = false, bool ignoreAllDefaultValue = false)
        {
            return _baseRepository.UpdateNotNullColumns(model, ignoreAllNullColumns, isOffIdentity, ignoreAllDefaultValue);
        }

        public Task<bool> UpdateRange(List<T> list)
        {
            return _baseRepository.UpdateRange(list);
        }

        public Task<DataTable> UseStoredProcedure(string procedureName, params SugarParameter[] parameters)
        {
            return _baseRepository.UseStoredProcedure(procedureName, parameters);
        }

        public Task<DbResult<bool>> UseTran(Action action, Action<Exception> errorCallBack)
        {
            return _baseRepository.UseTran(action, errorCallBack);
        }

        public Task<DbResult<S>> UseTran<S>(Func<S> func, Action<Exception> errorCallBack)
        {
            return _baseRepository.UseTran<S>(func, errorCallBack);
        }
    }

 

IStudentInfoService

 public interface IStudentInfoService : IBaseService<StudentInfo>
    {
    }

 

StudentInfoService

public class StudentInfoService : BaseService<StudentInfo>, IStudentInfoService
    {
        public StudentInfoService(IBaseRepository<StudentInfo> baseRepository)
            : base(baseRepository)
        {
        }
    }

 

Startup

// This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();

           services.AddTransient(typeof(IBaseRepository<>), typeof(BaseRepository<>));

            services.AddTransient<IStudentInfoService, StudentInfoService>();
          
            services.AddTransient<IDbContext, AppDbContext>();
        }