【.Net Core从零开始前后端分离】（六）——泛型基类异步编程

前言

这一章节学习一下泛型基类的搭建以及异步编程

构建各分层的基类

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