.NET Core 异步编程

public class BaseService<T> : IBaseService<T> where T : BaseEntity
    {
        private readonly EntityDbContext context;
        public BaseService(EntityDbContext _context)
        {
            this.context = _context;
        }

        /// <summary>
        /// 添加实体
        /// </summary>
        /// <param name="entity">实体参数</param>
        /// <returns></returns>
        async Task<bool> IBaseService<T>.InsertAsync(T entity)
        {
            if (entity == null)
                return false;
            try
            {
                if (entity != null)
                {
                    await context.Set<T>().AddAsync(entity);
                    return await context.SaveChangesAsync() > 0;
                }
            }
            catch
            {
                return false;
            }
            return false;
        }

        /// <summary>
        /// 修改实体
        /// </summary>
        /// <param name="entity">实体参数</param>
        /// <returns></returns>
        async Task<bool> IBaseService<T>.UpdateAsync(T entity)
        {
            if (entity == null)
                return false;
            try
            {
                if (entity != null)
                {
                    context.Set<T>().Update(Entity);
                    return await context.SaveChangesAsync() > 0;
                }

            }
            catch
            {
                return false;
            }
            return false;
        }

        /// <summary>
        /// 软删除
        /// </summary>
        /// <param name="entity">实体参数</param>
        /// <returns></returns>
        async Task<bool> IBaseService<T>.DeleteAsync(T entity)
        {
            if (entity == null)
                return false;
            try
            {
                T temp = context.Set<T>().Find(entity.Id);
                if (temp != null)
                {
                    context.Set<T>().Attach(temp);
                    temp.IsDeleted = true;
                    context.Entry<T>(temp).State = EntityState.Modified;
                    return await context.SaveChangesAsync() > 0;
                }
            }
            catch
            {
                return false;
            }
            return false;
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="entity">实体参数</param>
        /// <returns></returns>
        async Task<bool> IBaseService<T>.DeletesAsync(T entity)
        {
            if (entity == null)
                return false;
            try
            {
                T temp = context.Set<T>().Find(entity.Id);
                if (temp != null)
                {
                    context.Set<T>().Remove(temp);
                    return await context.SaveChangesAsync() > 0;
                }
            }
            catch
            {
                return false;
            }
            return false;
        }

        /// <summary>
        /// 实体查询
        /// </summary>
        /// <param name="whereLambda">查询条件</param>
        /// <param name="includes">外键表</param>
        /// <returns></returns>
        async Task<T> IBaseService<T>.FirstAsync(Expression<Func<T, bool>> whereLambda, string[] includes)
        {
            try
            {
                var model = context.Set<T>().AsNoTracking().Where(p => p.IsDeleted == false);

                if (includes != null && includes.Any())
                {
                    foreach (var include in includes)
                    {
                        model = model.Include(include);
                    }
                }
                return await model.FirstOrDefaultAsync(whereLambda);
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 全部查询
        /// </summary>
        /// <param name="lambdaWhere">查询条件</param>
        /// <param name="includes">外键表</param>
        /// <returns></returns>
        async Task<List<T>> IBaseService<T>.SelectAsync(Expression<Func<T, bool>> lambdaWhere, string[] includes)
        {
            try
            {
                IQueryable<T> model = context.Set<T>().AsNoTracking().Where(p => p.IsDeleted == false);

                if (includes != null && includes.Any())
                {
                    foreach (var include in includes)
                    {
                        model = model.Include(include);
                    }
                }
                if (lambdaWhere != null)
                {
                    model = model.Where(lambdaWhere);
                }
                return await model.ToListAsync();
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 查找分页列表(带条件,单字段lambda表达式排序)
        /// </summary>
        /// <typeparam name="type">排序字段类型</typeparam>
        /// <param name="pageSize">每页记录数</param>
        /// <param name="pageIndex">页码,首页从1开始</param>
        /// <param name="totalNumber">输出总数</param>
        /// <param name="isAsc">是否升序</param>
        /// <param name="OrderByLambda">排序条件</param>
        /// <param name="lambdaWhere">查询条件</param>
        /// <param name="includes">外键表</param>
        /// <returns></returns>
        IQueryable<T> IBaseService<T>.FindPageList<type>(int pageSize, int pageIndex, out int totalNumber, bool isAsc, Expression<Func<T, type>> OrderByLambda, Expression<Func<T, bool>> lambdaWhere, string[] includes)
        {
            try
            {

                IQueryable<T> model = context.Set<T>().AsNoTracking().Where(p => p.IsDeleted == false);

                if (includes != null && includes.Any())
                {
                    foreach (var include in includes)
                    {
                        model = model.Include(include);
                    }
                }
                if (lambdaWhere != null)
                {
                    model = model.Where(lambdaWhere);
                }
                totalNumber = model.Count();

                //是否升序
                if (isAsc)
                {
                    model = model.OrderBy(OrderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize);
                }
                else
                {
                    model = model.OrderByDescending(OrderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize);
                }

                return model;
            }
            catch
            {
                totalNumber = 0;
                return null;
            }
        }
    }