Display per page not being preserved

Nop.Web.Factories.CatalogModelFactory.cs

PrepareSortingOptions 

public virtual void PrepareSortingOptions(CatalogPagingFilteringModel pagingFilteringModel, CatalogPagingFilteringModel command)
        {
            if (pagingFilteringModel == null)
                throw new ArgumentNullException(nameof(pagingFilteringModel));

            if (command == null)
                throw new ArgumentNullException(nameof(command));

            //set the order by position by default
            pagingFilteringModel.OrderBy = command.OrderBy;
            command.OrderBy = (int)ProductSortingEnum.Position;

            //ensure that product sorting is enabled
            if (!_catalogSettings.AllowProductSorting)
                return;

            //get active sorting options
            var activeSortingOptionsIds = Enum.GetValues(typeof(ProductSortingEnum)).Cast<int>()
                .Except(_catalogSettings.ProductSortingEnumDisabled).ToList();
            if (!activeSortingOptionsIds.Any())
                return;

            //order sorting options
            var orderedActiveSortingOptions = activeSortingOptionsIds
                .Select(id => new { Id = id, Order = _catalogSettings.ProductSortingEnumDisplayOrder.TryGetValue(id, out int order) ? order : id })
                .OrderBy(option => option.Order).ToList();

            pagingFilteringModel.AllowProductSorting = true;

            int gridSelectedSorting = genericAttributeService.GetAttribute<int>(_workContext.CurrentCustomer, "GridSelectedSorting");
            if (!pagingFilteringModel.OrderBy.HasValue)
            {
                if (gridSelectedSorting == 0)
                {
                    command.OrderBy = orderedActiveSortingOptions.FirstOrDefault().Id;
                    genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, "GridSelectedSorting", command.OrderBy);
                }
                else
                {
                    command.OrderBy = gridSelectedSorting;
                }
            }
            else if (pagingFilteringModel.OrderBy.Value != gridSelectedSorting)
            {
                command.OrderBy = pagingFilteringModel.OrderBy.Value;
                gridSelectedSorting = pagingFilteringModel.OrderBy.Value;
                genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, "GridSelectedSorting", gridSelectedSorting);
            }
            else
                command.OrderBy = pagingFilteringModel.OrderBy.Value;

            //prepare available model sorting options
            var currentPageUrl = _webHelper.GetThisPageUrl(true);
            foreach (var option in orderedActiveSortingOptions)
            {
                pagingFilteringModel.AvailableSortOptions.Add(new SelectListItem
                {
                    Text = _localizationService.GetLocalizedEnum((ProductSortingEnum)option.Id),
                    Value = _webHelper.ModifyQueryString(currentPageUrl, "orderby", option.Id.ToString()),
                    Selected = option.Id == command.OrderBy
                });
            }
        }

PreparePageSizeOptions 

public virtual void PreparePageSizeOptions(CatalogPagingFilteringModel pagingFilteringModel, CatalogPagingFilteringModel command,
            bool allowCustomersToSelectPageSize, string pageSizeOptions, int fixedPageSize)
        {
            if (pagingFilteringModel == null)
                throw new ArgumentNullException(nameof(pagingFilteringModel));

            if (command == null)
                throw new ArgumentNullException(nameof(command));

            if (command.PageNumber <= 0)
            {
                command.PageNumber = 1;
            }
            pagingFilteringModel.AllowCustomersToSelectPageSize = false;
            if (allowCustomersToSelectPageSize && pageSizeOptions != null)
            {
                var pageSizes = pageSizeOptions.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                int gridSelectedPageSize = genericAttributeService.GetAttribute<int>(_workContext.CurrentCustomer, "GridSelectedPageSize");
                if (pageSizes.Any())
                {
                    // get the first page size entry to use as the default (category page load) or if customer enters invalid value via query string
                    if (command.PageSize <= 0 || !pageSizes.Contains(command.PageSize.ToString()))
                    {
                        if (gridSelectedPageSize == 0)
                        {
                            if (int.TryParse(pageSizes.FirstOrDefault(), out int temp))
                            {
                                if (temp > 0)
                                {
                                    command.PageSize = temp;
                                    genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, "GridSelectedPageSize", command.PageSize);
                                }
                            }
                        }
                        else
                            command.PageSize = gridSelectedPageSize;
                    }
                    else if (command.PageSize > 0 && command.PageSize != gridSelectedPageSize)
                    {
                        gridSelectedPageSize = command.PageSize;
                        genericAttributeService.SaveAttribute(_workContext.CurrentCustomer, "GridSelectedPageSize", gridSelectedPageSize);
                    }

                    var currentPageUrl = _webHelper.GetThisPageUrl(true);
                    var sortUrl = _webHelper.RemoveQueryString(currentPageUrl, "pagenumber");

                    foreach (var pageSize in pageSizes)
                    {
                        if (!int.TryParse(pageSize, out int temp))
                        {
                            continue;
                        }
                        if (temp <= 0)
                        {
                            continue;
                        }

                        pagingFilteringModel.PageSizeOptions.Add(new SelectListItem
                        {
                            Text = pageSize,
                            Value = _webHelper.ModifyQueryString(sortUrl, "pagesize", pageSize),
                            Selected = pageSize.Equals(command.PageSize.ToString(), StringComparison.InvariantCultureIgnoreCase)
                        });
                    }

                    if (pagingFilteringModel.PageSizeOptions.Any())
                    {
                        pagingFilteringModel.PageSizeOptions = pagingFilteringModel.PageSizeOptions.OrderBy(x => int.Parse(x.Text)).ToList();
                        pagingFilteringModel.AllowCustomersToSelectPageSize = true;

                        if (command.PageSize <= 0)
                        {
                            command.PageSize = int.Parse(pagingFilteringModel.PageSizeOptions.First().Text);
                        }
                    }
                }
            }
            else
            {
                //customer is not allowed to select a page size
                command.PageSize = fixedPageSize;
            }

            //ensure pge size is specified
            if (command.PageSize <= 0)
            {
                command.PageSize = fixedPageSize;
            }
        }