2. 程式人生 > 實用技巧 >【.Net Core從零開始前後端分離】（六）——泛型基類非同步程式設計

【.Net Core從零開始前後端分離】（六）——泛型基類非同步程式設計

阿新 • • 發佈：2020-12-24

前言

這一章節學習一下泛型基類的搭建以及非同步程式設計

構建各分層的基類

1、在Blog.Core.IRepository 層中新增BASE資料夾，並新增介面 IBaseRepository.cs

   public interface IBaseRepository<TEntity> where TEntity : class
   {

    Task<TEntity> QueryByID(object objId);
    Task<TEntity> QueryByID(object objId, bool blnUseCache = false);
    Task<List<TEntity>> QueryByIDs(object[] lstIds);

    Task<int> Add(TEntity model);

    Task<bool> DeleteById(object id);

    Task<bool> Delete(TEntity model);

    Task<bool> DeleteByIds(object[] ids);

    Task<bool> Update(TEntity model);
    Task<bool> Update(TEntity entity, string strWhere);
    Task<bool> Update(TEntity entity, List<string> lstColumns = null, List<string> lstIgnoreColumns = null, string strWhere = "");

    Task<List<TEntity>> Query();
    Task<List<TEntity>> Query(string strWhere);
    Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression);
    Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, string strOrderByFileds);
    Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression, bool isAsc = true);
    Task<List<TEntity>> Query(string strWhere, string strOrderByFileds);
    Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, int intTop, string strOrderByFileds);
    Task<List<TEntity>> Query(string strWhere, int intTop, string strOrderByFileds);
    Task<List<TEntity>> Query(
        Expression<Func<TEntity, bool>> whereExpression, int intPageIndex, int intPageSize, string strOrderByFileds);
    Task<List<TEntity>> Query(string strWhere, int intPageIndex, int intPageSize, string strOrderByFileds);
    Task<List<TEntity>> QueryPage(Expression<Func<TEntity, bool>> whereExpression, int intPageIndex = 0, int intPageSize = 20, string strOrderByFileds =             
    null);
}

2、IAdvertisementRepository 繼承Base基類

public interface IAdvertisementRepository:IBaseRepository<Advertisement>
{
    int Sum(int i, int j);

    //int Add(Advertisement model);
    //bool Delete(Advertisement model);
    //bool Update(Advertisement model);
    //List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression);
}

3、在Blog.Core.Repository 層中新增BASE資料夾，並新增介面 Repository.cs

   public class BaseRepository<TEntity> : IBaseRepository<TEntity> where TEntity : class, new()
{
    private DbContext context;
    private SqlSugarClient db;
    private SimpleClient<TEntity> entityDB;

    public DbContext Context
    {
        get { return context; }
        set { context = value; }
    }
    internal SqlSugarClient Db
    {
        get { return db; }
        private set { db = value; }
    }
    internal SimpleClient<TEntity> EntityDB
    {
        get { return entityDB; }
        private set { entityDB = value; }
    }
    public BaseRepository()
    {
        DbContext.Init(BaseDBConfig.ConnectionString);
        DbContext.DbType = DbType.MySql;
        context = DbContext.GetDbContext();
        db = context.Db;
        entityDB = context.GetEntityDB<TEntity>(db);
    }



    public async Task<TEntity> QueryByID(object objId)
    {
        return await Task.Run(() => db.Queryable<TEntity>().InSingle(objId));
    }
    /// <summary>
    /// 功能描述:根據ID查詢一條資料
    /// 作　　者:Blog.Core
    /// </summary>
    /// <param name="objId">id（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件</param>
    /// <param name="blnUseCache">是否使用快取</param>
    /// <returns>資料實體</returns>
    public async Task<TEntity> QueryByID(object objId, bool blnUseCache = false)
    {
        return await Task.Run(() => db.Queryable<TEntity>().WithCacheIF(blnUseCache).InSingle(objId));
    }

    /// <summary>
    /// 功能描述:根據ID查詢資料
    /// 作　　者:Blog.Core
    /// </summary>
    /// <param name="lstIds">id列表（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件</param>
    /// <returns>資料實體列表</returns>
    public async Task<List<TEntity>> QueryByIDs(object[] lstIds)
    {
        return await Task.Run(() => db.Queryable<TEntity>().In(lstIds).ToList());
    }

    /// <summary>
    /// 寫入實體資料
    /// </summary>
    /// <param name="entity">博文實體類</param>
    /// <returns></returns>
    public async Task<int> Add(TEntity entity)
    {
        var i = await Task.Run(() => db.Insertable(entity).ExecuteReturnBigIdentity());
        //返回的i是long型別,這裡你可以根據你的業務需要進行處理
        return (int)i;
    }

    /// <summary>
    /// 更新實體資料
    /// </summary>
    /// <param name="entity">博文實體類</param>
    /// <returns></returns>
    public async Task<bool> Update(TEntity entity)
    {
        //這種方式會以主鍵為條件
        var i = await Task.Run(() => db.Updateable(entity).ExecuteCommand());
        return i > 0;
    }

    public async Task<bool> Update(TEntity entity, string strWhere)
    {
        return await Task.Run(() => db.Updateable(entity).Where(strWhere).ExecuteCommand() > 0);
    }

    public async Task<bool> Update(string strSql, SugarParameter[] parameters = null)
    {
        return await Task.Run(() => db.Ado.ExecuteCommand(strSql, parameters) > 0);
    }

    public async Task<bool> Update(
      TEntity entity,
      List<string> lstColumns = null,
      List<string> lstIgnoreColumns = null,
      string strWhere = ""
        )
    {
        IUpdateable<TEntity> up = await Task.Run(() => db.Updateable(entity));
        if (lstIgnoreColumns != null && lstIgnoreColumns.Count > 0)
        {
            up = await Task.Run(() => up.IgnoreColumns(it => lstIgnoreColumns.Contains(it)));
        }
        if (lstColumns != null && lstColumns.Count > 0)
        {
            up = await Task.Run(() => up.UpdateColumns(it => lstColumns.Contains(it)));
        }
        if (!string.IsNullOrEmpty(strWhere))
        {
            up = await Task.Run(() => up.Where(strWhere));
        }
        return await Task.Run(() => up.ExecuteCommand()) > 0;
    }

    /// <summary>
    /// 根據實體刪除一條資料
    /// </summary>
    /// <param name="entity">博文實體類</param>
    /// <returns></returns>
    public async Task<bool> Delete(TEntity entity)
    {
        var i = await Task.Run(() => db.Deleteable(entity).ExecuteCommand());
        return i > 0;
    }

    /// <summary>
    /// 刪除指定ID的資料
    /// </summary>
    /// <param name="id">主鍵ID</param>
    /// <returns></returns>
    public async Task<bool> DeleteById(object id)
    {
        var i = await Task.Run(() => db.Deleteable<TEntity>(id).ExecuteCommand());
        return i > 0;
    }

    /// <summary>
    /// 刪除指定ID集合的資料(批量刪除)
    /// </summary>
    /// <param name="ids">主鍵ID集合</param>
    /// <returns></returns>
    public async Task<bool> DeleteByIds(object[] ids)
    {
        var i = await Task.Run(() => db.Deleteable<TEntity>().In(ids).ExecuteCommand());
        return i > 0;
    }



    /// <summary>
    /// 功能描述:查詢所有資料
    /// 作　　者:Blog.Core
    /// </summary>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query()
    {
        return await Task.Run(() => entityDB.GetList());
    }

    /// <summary>
    /// 功能描述:查詢資料列表
    /// 作　　者:Blog.Core
    /// </summary>
    /// <param name="strWhere">條件</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(string strWhere)
    {
        return await Task.Run(() => db.Queryable<TEntity>().WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToList());
    }

    /// <summary>
    /// 功能描述:查詢資料列表
    /// 作　　者:Blog.Core
    /// </summary>
    /// <param name="whereExpression">whereExpression</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression)
    {
        return await Task.Run(() => entityDB.GetList(whereExpression));
    }

    /// <summary>
    /// 功能描述:查詢一個列表
    /// 作　　者:Blog.Core
    /// </summary>
    /// <param name="whereExpression">條件表示式</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, string strOrderByFileds)
    {
        return await Task.Run(() => db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).ToList());
    }
    /// <summary>
    /// 功能描述:查詢一個列表
    /// </summary>
    /// <param name="whereExpression"></param>
    /// <param name="orderByExpression"></param>
    /// <param name="isAsc"></param>
    /// <returns></returns>
    public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression, bool isAsc = true)
    {
        return await Task.Run(() => db.Queryable<TEntity>().OrderByIF(orderByExpression != null, orderByExpression, isAsc ? OrderByType.Asc : OrderByType.Desc).WhereIF(whereExpression != null, whereExpression).ToList());
    }

    /// <summary>
    /// 功能描述:查詢一個列表
    /// 作　　者:Blog.Core
    /// </summary>
    /// <param name="strWhere">條件</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(string strWhere, string strOrderByFileds)
    {
        return await Task.Run(() => db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToList());
    }


    /// <summary>
    /// 功能描述:查詢前N條資料
    /// 作　　者:Blog.Core
    /// </summary>
    /// <param name="whereExpression">條件表示式</param>
    /// <param name="intTop">前N條</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(
        Expression<Func<TEntity, bool>> whereExpression,
        int intTop,
        string strOrderByFileds)
    {
        return await Task.Run(() => db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).Take(intTop).ToList());
    }

    /// <summary>
    /// 功能描述:查詢前N條資料
    /// 作　　者:Blog.Core
    /// </summary>
    /// <param name="strWhere">條件</param>
    /// <param name="intTop">前N條</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(
        string strWhere,
        int intTop,
        string strOrderByFileds)
    {
        return await Task.Run(() => db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).Take(intTop).ToList());
    }

    /// <summary>
    /// 功能描述:分頁查詢
    /// 作　　者:Blog.Core
    /// </summary>
    /// <param name="whereExpression">條件表示式</param>
    /// <param name="intPageIndex">頁碼（下標0）</param>
    /// <param name="intPageSize">頁大小</param>
    /// <param name="intTotalCount">資料總量</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(
        Expression<Func<TEntity, bool>> whereExpression,
        int intPageIndex,
        int intPageSize,
        string strOrderByFileds)
    {
        return await Task.Run(() => db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).ToPageList(intPageIndex, intPageSize));
    }

    /// <summary>
    /// 功能描述:分頁查詢
    /// 作　　者:Blog.Core
    /// </summary>
    /// <param name="strWhere">條件</param>
    /// <param name="intPageIndex">頁碼（下標0）</param>
    /// <param name="intPageSize">頁大小</param>
    /// <param name="intTotalCount">資料總量</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(
      string strWhere,
      int intPageIndex,
      int intPageSize,
      string strOrderByFileds)
    {
        return await Task.Run(() => db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToPageList(intPageIndex, intPageSize));
    }

    public async Task<List<TEntity>> QueryPage(Expression<Func<TEntity, bool>> whereExpression,
    int intPageIndex = 0, int intPageSize = 20, string strOrderByFileds = null)
    {
        return await Task.Run(() => db.Queryable<TEntity>()
        .OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds)
        .WhereIF(whereExpression != null, whereExpression)
        .ToPageList(intPageIndex, intPageSize));
    }
}

4、AdvertisementRepository 繼承Base基類

public class AdvertisementRepository : BaseRepository<Advertisement>,IAdvertisementRepository
{
    //private DbContext context;
    //private SqlSugarClient db;
    //private SimpleClient<Advertisement> entityDB;

    //internal SqlSugarClient Db
    //{
    //    get { return db; }
    //    private set { db = value; }
    //}
    //public DbContext Context
    //{
    //    get { return context; }
    //    set { context = value; }
    //}
    //public AdvertisementRepository()
    //{
    //    DbContext.Init(BaseDBConfig.ConnectionString);
    //    DbContext.DbType = DbType.MySql;
    //    context = DbContext.GetDbContext();
    //    db = context.Db;
    //    entityDB = context.GetEntityDB<Advertisement>(db);
    //}
    //public int Add(Advertisement model)
    //{
    //    //返回的i是long型別,這裡你可以根據你的業務需要進行處理
    //    var i = db.Insertable(model).ExecuteReturnBigIdentity();
    //    return i.ObjToInt();
    //}

    //public bool Delete(Advertisement model)
    //{
    //    var i = db.Deleteable(model).ExecuteCommand();
    //    return i > 0;
    //}

    //public List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression)
    //{
    //    return entityDB.GetList(whereExpression);

    //}

    public int Sum(int i, int j)
    {
        return i + j;
    }

    //public bool Update(Advertisement model)
    //{
    //    //這種方式會以主鍵為條件
    //    var i = db.Updateable(model).ExecuteCommand();
    //    return i > 0;
    //}
}

5、在Blog.Core.IService 層中新增BASE資料夾，並新增介面 IBaseService.cs

public interface IBaseServices<TEntity> where TEntity : class
{

    Task<TEntity> QueryByID(object objId);
    Task<TEntity> QueryByID(object objId, bool blnUseCache = false);
    Task<List<TEntity>> QueryByIDs(object[] lstIds);

    Task<int> Add(TEntity model);

    Task<bool> DeleteById(object id);

    Task<bool> Delete(TEntity model);

    Task<bool> DeleteByIds(object[] ids);

    Task<bool> Update(TEntity model);
    Task<bool> Update(TEntity entity, string strWhere);

    Task<bool> Update(TEntity entity, List<string> lstColumns = null, List<string> lstIgnoreColumns = null, string strWhere = "");

    Task<List<TEntity>> Query();
    Task<List<TEntity>> Query(string strWhere);
    Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression);
    Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, string strOrderByFileds);
    Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression, bool isAsc = true);
    Task<List<TEntity>> Query(string strWhere, string strOrderByFileds);

    Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, int intTop, string strOrderByFileds);
    Task<List<TEntity>> Query(string strWhere, int intTop, string strOrderByFileds);

    Task<List<TEntity>> Query(
        Expression<Func<TEntity, bool>> whereExpression, int intPageIndex, int intPageSize, string strOrderByFileds);
    Task<List<TEntity>> Query(string strWhere, int intPageIndex, int intPageSize, string strOrderByFileds);

    Task<List<TEntity>> QueryPage(Expression<Func<TEntity, bool>> whereExpression, int intPageIndex = 0, int intPageSize = 20, string strOrderByFileds = null);
}

6、IAdvertisementServices 繼承Base基類

public interface IAdvertisementServices: IBaseServices<Advertisement>
{
    int Sum(int i, int j);
    //int Add(Advertisement model);
    //bool Delete(Advertisement model);
    //bool Update(Advertisement model);
    //List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression);
}

7、在Blog.Core.Service 層中新增BASE資料夾，並新增介面 BaseServices.cs

   public class BaseServices<TEntity> : IBaseServices<TEntity> where TEntity : class, new()
{
    public IBaseRepository<TEntity> baseDal = new BaseRepository<TEntity>();

    public async Task<TEntity> QueryByID(object objId)
    {
        return await baseDal.QueryByID(objId);
    }
    /// <summary>
    /// 功能描述:根據ID查詢一條資料
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <param name="objId">id（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件</param>
    /// <param name="blnUseCache">是否使用快取</param>
    /// <returns>資料實體</returns>
    public async Task<TEntity> QueryByID(object objId, bool blnUseCache = false)
    {
        return await baseDal.QueryByID(objId, blnUseCache);
    }

    /// <summary>
    /// 功能描述:根據ID查詢資料
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <param name="lstIds">id列表（必須指定主鍵特性 [SugarColumn(IsPrimaryKey=true)]），如果是聯合主鍵，請使用Where條件</param>
    /// <returns>資料實體列表</returns>
    public async Task<List<TEntity>> QueryByIDs(object[] lstIds)
    {
        return await baseDal.QueryByIDs(lstIds);
    }

    /// <summary>
    /// 寫入實體資料
    /// </summary>
    /// <param name="entity">博文實體類</param>
    /// <returns></returns>
    public async Task<int> Add(TEntity entity)
    {
        return await baseDal.Add(entity);
    }

    /// <summary>
    /// 更新實體資料
    /// </summary>
    /// <param name="entity">博文實體類</param>
    /// <returns></returns>
    public async Task<bool> Update(TEntity entity)
    {
        return await baseDal.Update(entity);
    }
    public async Task<bool> Update(TEntity entity, string strWhere)
    {
        return await baseDal.Update(entity, strWhere);
    }

    public async Task<bool> Update(
     TEntity entity,
     List<string> lstColumns = null,
     List<string> lstIgnoreColumns = null,
     string strWhere = ""
        )
    {
        return await baseDal.Update(entity, lstColumns, lstIgnoreColumns, strWhere);
    }


    /// <summary>
    /// 根據實體刪除一條資料
    /// </summary>
    /// <param name="entity">博文實體類</param>
    /// <returns></returns>
    public async Task<bool> Delete(TEntity entity)
    {
        return await baseDal.Delete(entity);
    }

    /// <summary>
    /// 刪除指定ID的資料
    /// </summary>
    /// <param name="id">主鍵ID</param>
    /// <returns></returns>
    public async Task<bool> DeleteById(object id)
    {
        return await baseDal.DeleteById(id);
    }

    /// <summary>
    /// 刪除指定ID集合的資料(批量刪除)
    /// </summary>
    /// <param name="ids">主鍵ID集合</param>
    /// <returns></returns>
    public async Task<bool> DeleteByIds(object[] ids)
    {
        return await baseDal.DeleteByIds(ids);
    }



    /// <summary>
    /// 功能描述:查詢所有資料
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query()
    {
        return await baseDal.Query();
    }

    /// <summary>
    /// 功能描述:查詢資料列表
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <param name="strWhere">條件</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(string strWhere)
    {
        return await baseDal.Query(strWhere);
    }

    /// <summary>
    /// 功能描述:查詢資料列表
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <param name="whereExpression">whereExpression</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression)
    {
        return await baseDal.Query(whereExpression);
    }
    /// <summary>
    /// 功能描述:查詢一個列表
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <param name="whereExpression">條件表示式</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression, bool isAsc = true)
    {
        return await baseDal.Query(whereExpression, orderByExpression, isAsc);
    }

    public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, string strOrderByFileds)
    {
        return await baseDal.Query(whereExpression, strOrderByFileds);
    }

    /// <summary>
    /// 功能描述:查詢一個列表
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <param name="strWhere">條件</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(string strWhere, string strOrderByFileds)
    {
        return await baseDal.Query(strWhere, strOrderByFileds);
    }

    /// <summary>
    /// 功能描述:查詢前N條資料
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <param name="whereExpression">條件表示式</param>
    /// <param name="intTop">前N條</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, int intTop, string strOrderByFileds)
    {
        return await baseDal.Query(whereExpression, intTop, strOrderByFileds);
    }

    /// <summary>
    /// 功能描述:查詢前N條資料
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <param name="strWhere">條件</param>
    /// <param name="intTop">前N條</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(
        string strWhere,
        int intTop,
        string strOrderByFileds)
    {
        return await baseDal.Query(strWhere, intTop, strOrderByFileds);
    }

    /// <summary>
    /// 功能描述:分頁查詢
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <param name="whereExpression">條件表示式</param>
    /// <param name="intPageIndex">頁碼（下標0）</param>
    /// <param name="intPageSize">頁大小</param>
    /// <param name="intTotalCount">資料總量</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(
        Expression<Func<TEntity, bool>> whereExpression,
        int intPageIndex,
        int intPageSize,
        string strOrderByFileds)
    {
        return await baseDal.Query(
          whereExpression,
          intPageIndex,
          intPageSize,
          strOrderByFileds);
    }

    /// <summary>
    /// 功能描述:分頁查詢
    /// 作　　者:AZLinli.Blog.Core
    /// </summary>
    /// <param name="strWhere">條件</param>
    /// <param name="intPageIndex">頁碼（下標0）</param>
    /// <param name="intPageSize">頁大小</param>
    /// <param name="intTotalCount">資料總量</param>
    /// <param name="strOrderByFileds">排序欄位，如name asc,age desc</param>
    /// <returns>資料列表</returns>
    public async Task<List<TEntity>> Query(
      string strWhere,
      int intPageIndex,
      int intPageSize,
      string strOrderByFileds)
    {
        return await baseDal.Query(
        strWhere,
        intPageIndex,
        intPageSize,
        strOrderByFileds);
    }

    public async Task<List<TEntity>> QueryPage(Expression<Func<TEntity, bool>> whereExpression,
    int intPageIndex = 0, int intPageSize = 20, string strOrderByFileds = null)
    {
        return await baseDal.QueryPage(whereExpression,
     intPageIndex = 0, intPageSize, strOrderByFileds);
    }

}

8、AdvertisementService 繼承Base基類

public class AdvertisementServices : BaseServices<Advertisement>,IAdvertisementServices
{
    public IAdvertisementRepository dal = new AdvertisementRepository();
    public int Sum(int i, int j)
    {
        return dal.Sum(i, j);

    }
    //public int Add(Advertisement model)
    //{
    //    return dal.Add(model);
    //}

    //public bool Delete(Advertisement model)
    //{
    //    return dal.Delete(model);
    //}

    //public List<Advertisement> Query(Expression<Func<Advertisement, bool>> whereExpression)
    //{
    //    return dal.Query(whereExpression);

    //}

    //public bool Update(Advertisement model)
    //{
    //    return dal.Update(model);
    //}
}

二、執行專案，並除錯介面

這個時候，需要把介面改成非同步請求方式：

   // GET: api/Blog/5
    /// <summary>
    /// 根據id獲取資料
    /// </summary>
    /// <param name="id">引數id</param>
    /// <returns></returns>
    [HttpGet("{id}", Name = "Get")]
    public async Task<List<Advertisement>> Get(int id)
    {
        IAdvertisementServices advertisementServices = new AdvertisementServices();

        return await advertisementServices.Query(d => d.Id == id);
    }

Http返回200，一切正常

結語

這一章節抽取了泛型基類，並且將請求改為非同步請求。

Github

https://github.com/Nick-Hoper/Blog.Core.Demo.git

相關推薦

【.Net Core從零開始前後端分離】（六）——泛型基類非同步程式設計

前言 這一章節學習一下泛型基類的搭建以及非同步程式設計 構建各分層的基類

【.Net Core從零開始前後端分離】（二）——後端專案搭建

一、環境安裝 首先需要安裝 .Net Core的SDK環境。 下載 SDK 地址 ：https://dotnet.microsoft.com/download

【.Net Core從零開始前後端分離】（四）——倉儲+服務+抽象介面模式

前言 這一章節學習後端專案的分層，主要分為API、Models、倉儲層、服務層 各層之間的呼叫關係：

從零開始的野路子React（3）打通前後端

相信很多人都聽說過前後端分離這個概念，一直以來我比較好奇的一件事是，分離了之後我們怎麼再讓資料在前後端流通呢？最近正好學習了一下。

【九圖流】從零開始設計一個登入系統（初中級）

說明： 無任何程式碼，只有設計思路。 範疇等級：初級開發、中級開發。 場景：中小型專案，內部專案。

從零開始的野路子React（2）路由與頁面跳轉

這兩天主要摸索了一下React的路由做法，網上看了一些資料，但總覺得比較零散，所以自己稍微總結一下，好讓自己明白一些。

從零開始手寫快取框架（12）redis expire 過期的隨機特性詳解及實現

前言 java從零手寫實現redis（一）如何實現固定大小的快取？ java從零手寫實現redis（二）redis expire 過期原理

從零開始搭建公司域環境（九）：搭建WDS（Windows部署服務）來輕鬆安裝部署電腦作業系統

注：以下實驗均在Oracle VM VirtualBox的虛擬機器中完成，實際搭建時需要考慮的問題肯定更多更復雜，寫此係列文章僅作為記錄和分享，請各位在實地搭建時參考更多的相關資料或諮詢相關有經驗的人員。

<Re:從零開始的演算法總結>（1）--動態規劃問題

判斷動態規劃問題 動態規劃問題的一般形式是求最值，比如最長遞增序列、最小編輯距離等等

從零開始的react入門教程（五），瞭解react中的表單，何為受控元件與非受控元件

壹 ❀ 引 我們在從零開始的react入門教程（四），瞭解常用的條件渲染、列表渲染與獨一無二的key一文中介紹了react中常用的條件渲染操作，比如三元運算子，邏輯運算子等，結合react元件或者react元素，我們能做到很多

new file()的路徑能用中文嗎_從零開始寫文字編輯器（八）：介面文字支援中文...

技術標籤：new file()的路徑能用中文嗎 程式設計師這行業有點噁心的地方在於，很多小眾領域的優秀軟體沒有中文，其實也不是故意不支援中文，多半是計算機發展的歷史原因。

從零開始的Java學習生活（16）

技術標籤：從零開始的Java學習 文章目錄 前言一、多型（1）什麼是多型（2）程式中的多型3）多型示例

從零開始WPF開發組態（二）

技術標籤：專案wpfc# 從零開始WPF開發組態（一） 右擊選單 上一節介紹了本次的開發工具，也剛剛建立了一個專案，接下來就要正式開發了。

從零開始的react入門教程（八），redux起源與基礎用法

壹 ❀ 引 我們在從零開始的react入門教程（七），react中的狀態提升，我們為什麼需要使用redux一文中介紹了react的狀態提升，對於不同元件之間狀態需要通訊時，將狀態提升至兩個元件共有的最近父元件進行管理是官方

從零開始製作 NuGet 原始碼包（全面支援 .NET Core / .NET Framework / WPF 專案）

========================================================================================= 微軟官方建立NuGet包說明文件

【從零開始學習Node.js】一.在CentOS 7中部署Node.js環境

一.背景資訊 Node.js是一個基於Chrome V8引擎的JavaScript執行環境，用來方便快速地搭建易於擴充套件的網路應用。Node.js使用了一個事件驅動、非阻塞式I/O的模型，使其輕量又高效，非常適合執行在分散式裝置的資料

net根據list建立xml_從零開始寫文字編輯器（二十五）：支援對目錄URL遍歷XML資源...

技術標籤：net根據list建立xml 前言 現階段的資源載入是固定的 string.xml 來載入所有字串資源。但一個檔案顯然不利於編輯和分類。當我把所有選單項字串列出時，已經多達230個，更不論對話方塊/按鈕等使用的字串

【從零開始擼一個App】RecyclerView的使用

技術標籤：android 目標 前段時間打造了一款簡單易用功能全面的圖片上傳元件，現在就來將上傳的圖片以圖片集的形式展現到App上。出於使用者體驗考慮，載入新圖片採用[無限]滾動模式，Android平臺上我們優選Recyc

.Net WebApi2從零開始

1、建立 　　VS建立WebApi應用，模板選擇空模板，核心應用選擇Web Api，右鍵解決方案在生成中勾選生產Xml檔案。

從零開始初嘗Three.js（大量案例、簡單入手）

不經意間看到了某個官網的動態效果~ 實在是太帥啦！十分地友好 查了查實現該效果地技術 —— 原來是Three.js