在.Net Core 2中使用Razor页面进行分页问题 - 第2部分

Question

我们正在学习Paging教程 - https://docs.microsoft.com/en-us/aspnet/core/data/ef-rp/sort-filter-page?view=aspnetcore-2.1。

我们将3设置为测试的页面大小，我们在查询中返回54条记录。由于某些原因，var count = await source.CountAsync（）;在下面这个返回为3？！？！有任何想法吗？

public static async Task<PaginatedList<T>> CreateAsync(
            IQueryable<T> source, int pageIndex, int pageSize)
        {
            var count = await source.CountAsync();
            var items = await source.Skip(
                (pageIndex - 1) * pageSize)
                .Take(pageSize).ToListAsync();
            return new PaginatedList<T>(items, count, pageIndex, pageSize);
        }

PaginatedList.cs类：

public class PaginatedList<T> : List<T>
    {
        public int PageIndex { get; private set; }
        public int TotalPages { get; private set; }

        public PaginatedList(List<T> items, int count, int pageIndex, int pageSize)
        {
            PageIndex = pageIndex;
            TotalPages = (int)Math.Ceiling(count / (double)pageSize);

            this.AddRange(items);
        }

        public bool HasPreviousPage
        {
            get
            {
                return (PageIndex > 1);
            }
        }

        public bool HasNextPage
        {
            get
            {
                return (PageIndex < TotalPages);
            }
        }

        public static async Task<PaginatedList<T>> CreateAsync(
            IQueryable<T> source, int pageIndex, int pageSize)
        {
            var count = await source.CountAsync();
            var items = await source.Skip(
                (pageIndex - 1) * pageSize)
                .Take(pageSize).ToListAsync();
            return new PaginatedList<T>(items, count, pageIndex, pageSize);
        }
    }

这是index.cshtml的后端代码：

public class IndexModel : PageModel
    {
        private readonly AthlosifyWebArchery.Data.ApplicationDbContext _context;

        public IndexModel(AthlosifyWebArchery.Data.ApplicationDbContext context)
        {
            _context = context;
        }

        public string AtheleteNameSort { get; set; }

        public string GenderSort { get; set; }

        public string TotalRankingScoreSort { get; set; }

        public string CurrentSort { get; set; }

        public string CurrentFilter { get; set; }

        public class TournamentAtheleteViewModel
        {
             public string AtheleteName { get; set; }

            public string Gender { get; set; }

            public string Contingent { get; set; }

            public double TotalRankingScore { get; set; }
        }

        [BindProperty]
        public PaginatedList<TournamentAtheleteViewModel> TournamentAtheletes { get;set; }

        public async Task OnGetAsync(string sortOrder, string currentFilter, string searchString, int? pageIndex)
        {
            CurrentSort = sortOrder;

            AtheleteNameSort = String.IsNullOrEmpty(sortOrder) ? "atheletename_desc" : "";
            GenderSort = sortOrder == "gender" ? "gender_desc" : "gender";
            TotalRankingScoreSort = sortOrder == "totalrankingscore" ? "totalrankingscore_desc" : "totalrankingscore";

            if (searchString != null)
            {
                pageIndex = 1;
            }
            else
            {
                searchString = currentFilter;
            }

            CurrentFilter = searchString;


            IQueryable<TournamentAtheleteViewModel> atheletes  = _context.TournamentBatchItem
                                    .GroupBy(t => new { t.AtheleteName, t.Gender, t.Contingent })
                                    .Select(t => new TournamentAtheleteViewModel { AtheleteName = t.Key.AtheleteName,
                                                                                    Gender = t.Key.Gender,
                                                                                    Contingent = t.Key.Contingent,
                                                                                    TotalRankingScore = t.Sum(i => i.RankingScore) });
            if (!String.IsNullOrEmpty(searchString))
            {
                atheletes = atheletes.Where(s => s.AtheleteName.Contains(searchString)
                                                    || s.Contingent.Contains(searchString));
            }


            switch (sortOrder)
            {
                case "atheletename_desc":
                    atheletes = atheletes.OrderByDescending(s => s.AtheleteName);
                    break;
                case "gender":
                    atheletes = atheletes.OrderBy(s => s.Gender);
                    break;
                case "gender_desc":
                    atheletes = atheletes.OrderByDescending(s => s.Gender);
                    break;
                case "totalrankingscore":
                    atheletes = atheletes.OrderByDescending(s => s.TotalRankingScore);
                    break;
                case "totalrankingscore_desc":
                    atheletes = atheletes.OrderBy(s => s.TotalRankingScore);
                    break;
                default:
                    atheletes = atheletes.OrderBy(s => s.AtheleteName);
                    break;

            }

            int pageSize = 3;

            //TournamentAtheletes = await atheletes.AsNoTracking().ToListAsync();
            TournamentAtheletes = await PaginatedList<TournamentAtheleteViewModel>.CreateAsync(
                                    atheletes.AsNoTracking(), pageIndex ?? 1, pageSize);




        }
    }

Answer 1

实际上，我改为：

var count = await source.CountAsync();

至

var count = await source.ToAsyncEnumerable().Count();

这返回了正确的计数。