public PagedResultDto(IPagedResultRequest request, long totalItems, IReadOnlyList <T> items) { CurrentPage = request.PageIndex; TotalItems = totalItems; ItemsPerPage = request.PageSize; Items = items; }
public static IQueryable <T> PageBy <T>([NotNull] this IQueryable <T> query, [NotNull] IPagedResultRequest pagedResultRequest) { Check.NotNull(query, nameof(query)); Check.NotNull(pagedResultRequest, nameof(pagedResultRequest)); return(query.PageBy(pagedResultRequest.SkipCount, pagedResultRequest.MaxResultCount)); }
/// <summary> /// 应用requestInput指定的分页参数 /// </summary> public static IQueryable <T> ApplyPaging <T>(this IQueryable <T> query, IPagedResultRequest requestInput = null) where T : class { if (requestInput != null) { return(query.PageBy(requestInput)); } return(query); }
public IPagedResult <TOutput> GetPage(IPagedResultRequest input) { var result = _entityRepository.PageBy(input); var mapResult = ObjectMapper.Map <List <TEntity>, List <TOutput> >(result.ToList()); return(new PagedResultDto <TOutput>(result.Count(), mapResult)); }
protected List <TEntity> GetList(Expression <Func <TEntity, bool> > predicate, IPagedResultRequest pagedResultRequest, out int total) { var queryable = GetQueryable(predicate); total = queryable.Count(); return(queryable.OrderBy(t => t.Id).PageBy(pagedResultRequest).ToList()); }
public static IQueryable <TEntity> PageBy <TEntity>(this IOrderedQueryable <TEntity> entities, IPagedResultRequest pagedResultRequest) { if (entities == null) { throw new ArgumentNullException(nameof(entities)); } return(PageBy(entities, pagedResultRequest.PageSize, pagedResultRequest.PageIndex)); }
/// <summary> /// 将SQL包装为分页SQL /// </summary> /// <param name="rawSql">原始SQL(必须包含RowID的序号列)</param> /// <param name="paggerInput">分页输入</param> /// <returns>分页SQL</returns> protected virtual string getPaggerWapperSql(string rawSql, IPagedResultRequest paggerInput) { if (string.IsNullOrWhiteSpace(rawSql)) { throw new ArgumentNullException(nameof(rawSql)); } string sql = $@"SELECT * FROM ({rawSql}) AS _T WHERE _T.RowID BETWEEN {paggerInput.SkipCount + 1} AND {(paggerInput.SkipCount + paggerInput.MaxResultCount)} "; return(sql); }
/// <summary> /// 获取分页结果 /// </summary> /// <typeparam name="TEntity"></typeparam> /// <typeparam name="TModel"></typeparam> /// <param name="query"></param> /// <param name="request"></param> /// <returns></returns> public static async Task <PagedResult <TModel> > ToPageResultAsync <TEntity, TModel>( [NotNull] this IQueryable <TEntity> query, [NotNull] IPagedResultRequest request) where TModel : class { Check.NotNull(request, nameof(request)); var total = await query.LongCountAsync(); var items = await query.PageBy(request).ToListAsync(); var result = new PagedResult <TModel>(request, total, items.Select(MapToListOutput).ToList()); return(result);
public static async Task <IPagedResult <T> > ToPageResultAsync <T>(this IQueryable <T> query, IPagedResultRequest pagedResultRequest, bool findTotalCount = true) { var pageResult = new PagedResultDto <T>(); if (findTotalCount) { pageResult.TotalCount = await query.CountAsync(); } pageResult.Items = await query.Skip(pagedResultRequest.SkipCount).Take(pagedResultRequest.MaxResultCount) .ToListAsync(); return(pageResult); }
public static IPagedResult <T> ToPageResult <T>(this IQueryable <T> query, IPagedResultRequest pagedResultRequest, bool findTotalCount = true) { var pageResult = new PagedResultDto <T>(); if (findTotalCount) { var totalCount = query.Count(); pageResult.TotalCount = totalCount; } pageResult.Items = query.Skip(pagedResultRequest.SkipCount).Take(pagedResultRequest.MaxResultCount) .ToList(); return(pageResult); }
/// <summary> /// Should apply paging if needed. /// </summary> /// <param name="query">The query.</param> /// <param name="input">The input.</param> protected virtual IQueryable <TEntity> ApplyPaging <TEntity>(IQueryable <TEntity> query, IPagedResultRequest input) { //Try to use paging if available IPagedResultRequest pagedInput = input; if (pagedInput != null) { return(query.PageBy(pagedInput)); } //Try to limit query result if available ILimitedResultRequest limitedInput = input; if (limitedInput != null) { return(query.Take(limitedInput.MaxResultCount)); } //No paging return(query); }
public static IQueryable <T> Paging <T>(this IQueryable <T> query, IPagedResultRequest request) { query = query.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize); return(query); }
/// <summary> /// Used for paging. Can be used as an alternative to Skip(...).Take(...) chaining. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="query"></param> /// <param name="request">分页请求</param> /// <returns></returns> public static IQueryable <T> PageBy <T>([NotNull] this IQueryable <T> query, IPagedResultRequest request) { Check.NotNull(query, nameof(request)); return(PageBy(query, request.Page, request.Limit)); }
protected virtual async Task <PagedResultDto <T> > GetPagedResult <T>(IQueryable <T> query, IPagedResultRequest input) where T : class { IQueryable <T> items = ApplyPaging <T>(query, input); int count = await query.CountAsync(); return(new PagedResultDto <T>(count, await items.ToListAsync())); }
/// <summary> /// 获取分页结果 /// </summary> /// <typeparam name="TEntity"></typeparam> /// <param name="query"></param> /// <param name="request">分页请求</param> /// <returns></returns> public static async Task <PagedResult <TEntity> > ToPageResultAsync <TEntity>([NotNull] this IQueryable <TEntity> query, [NotNull] IPagedResultRequest request) { Check.NotNull(request, nameof(request)); var total = query.LongCount(); var items = query.PageBy(request); return(new PagedResult <TEntity>(request, total, await items.ToListAsync())); }
/// <summary> /// Used for paging with an <see cref="IPagedResultRequest"/> object. /// </summary> /// <param name="query">Queryable to apply paging</param> /// <param name="pagedResultRequest">An object implements <see cref="IPagedResultRequest"/> interface</param> public static IQueryable <T> PageBy <T>(this IQueryable <T> query, IPagedResultRequest pagedResultRequest) { return(query.PageBy(pagedResultRequest.PageIndex, pagedResultRequest.PageSize)); }
public static IPagedResult <T> PageBy <T>(this IEnumerable <T> query, IPagedResultRequest pagedResultRequest) { return(query.PageBy((pagedResultRequest.PageCount * (pagedResultRequest.PageIndex - 1)), pagedResultRequest.PageCount)); }
public IQueryable <TSource> ApplySorting <TSource, TSourcePrimaryKey>(IQueryable <TSource> query, IPagedResultRequest input) where TSource : class, IEntity <TSourcePrimaryKey> { //Try to sort query if available var sortInput = input as ISortedResultRequest; if (sortInput != null) { if (!sortInput.Sorting.IsNullOrWhiteSpace()) { return(query.OrderBy(sortInput.Sorting)); } } //IQueryable.Task requires sorting, so we should sort if Take will be used. if (input is ILimitedResultRequest) { return(query.OrderByDescending(e => e.Id)); } //No sorting return(query); }
/// <summary> /// Used for paging with an <see cref="IPagedResultRequest"/> object. /// </summary> /// <param name="query">Queryable to apply paging</param> /// <param name="pagedResultRequest">An object implements <see cref="IPagedResultRequest"/> interface</param> public static IQueryable <T> PageBy <T>(this IQueryable <T> query, IPagedResultRequest pagedResultRequest) { return(query.PageBy((pagedResultRequest.CurrentPage - 1) * pagedResultRequest.MaxResultCount, pagedResultRequest.MaxResultCount)); }
public IQueryable <TSource> ApplyPaging <TSource>(IQueryable <TSource> query, IPagedResultRequest input) { //Try to use paging if available var pagedInput = input as IPagedResultRequest; if (pagedInput != null) { return(query.PageBy(pagedInput)); } //Try to limit query result if available var limitedInput = input as ILimitedResultRequest; if (limitedInput != null) { return(query.Take(limitedInput.MaxResultCount)); } //No paging return(query); }
/// <summary> /// /// </summary> /// <typeparam name="TSource"></typeparam> /// <typeparam name="TResult"></typeparam> /// <param name="query"></param> /// <param name="page"></param> /// <param name="selector"></param> /// <returns></returns> public async static Task <PagedResultDto <TResult> > ToPagedResultAsync <TSource, TResult>(this IQueryable <TSource> query, IPagedResultRequest page, Expression <Func <TSource, TResult> > selector) where TResult : class { var count = await query.CountAsync(); var list = await query.Select(selector).Skip(page.SkipCount).Take(page.MaxResultCount).AsNoTracking().ToListAsync(); return(new PagedResultDto <TResult>(count, list)); }
public PagedResult(IPagedResultRequest request, long totalCount, IReadOnlyList <T> items) : this(request.Page, request.Limit, totalCount, items) { }
/// <summary> /// Used for paging with an <see cref="T:Abp.Application.Services.Dto.IPagedResultRequest" /> object. /// </summary> /// <param name="query">Queryable to apply paging</param> /// <param name="pagedResultRequest">An object implements <see cref="T:Abp.Application.Services.Dto.IPagedResultRequest" /> interface</param> public static IQueryable <T> PageBy <T>(this IQueryable <T> query, IPagedResultRequest pagedResultRequest) { return(PageBy(query, pagedResultRequest.SkipCount, pagedResultRequest.MaxResultCount)); }
protected async Task <PagedResultDto <TDestination> > GetAllPagedByQueryFilter <TDestination, TSource, TSourcePrimaryKey>(IQueryable <TSource> query, IPagedResultRequest input) where TSource : class, IEntity <TSourcePrimaryKey> { var totalCount = await query.CountAsync(); query = ApplySorting <TSource, TSourcePrimaryKey>(query, input); query = ApplyPaging(query, input); var entities = await query.ToListAsync(); return(new PagedResultDto <TDestination>( totalCount, entities.Select(v => v.MapTo <TDestination>()).ToList() )); }