已确认并接受的分页导航渲染算法或实用程序？

Question

是否已经有一个公认的 .NET 实现来实现带有跳过的页面导航渲染？例如：

1) 12 页，子集大小 6，当前页 9 将生成：1 ... 9 10 11 12（点通向第 4 页）

2) 5 页，子集大小 3，当前页 3 将产生： ... 3 ... （点通向 1-2 和 4-5）

3) 14 页，子集大小 8，当前页 6 将产生：1 ... 5 6 8 9 ... 14（点通向 3 和 11）

结果必须是用于渲染的数组或列表。下面的链接没有给出可接受的 实施/单元测试：

智能分页算法

创建分页链接的算法/伪代码？

制作第一个、最后一个、下一个 10、上一个 10 在这里无关紧要。

我自己做这件事感觉就像重新发明自行车。

Answer 1

没有答案，不得不自己写。也许这对某人有用......

负值表明必须使用“...”，并且该值的abs给出“...”通向的页码。结果数组将用于渲染导航页面。

/// <summary>
        /// Creates the template to be used for rendering the page navigation with skips.
        /// </summary>
        /// <param name="a_pagesNum"></param> Total pages number
        /// <param name="a_pageSetSize"></param> The size of the page set to render
        /// <param name="a_curPageNum"></param> The current page number (not index)
        /// <returns></returns>
public static int[] DoPageDist(int a_pagesNum, int a_pageSetSize, int a_curPageNum)
        {
            // Validate 
            if (a_pagesNum < 1 || a_pageSetSize < 1 || a_curPageNum < 1 | a_curPageNum > a_pagesNum)
            {
                return null;
            }

            if (a_pageSetSize > a_pagesNum)
            {
                a_pageSetSize = a_pagesNum;
            }

            // What are the conditions around the current index?
            int leftNums = a_curPageNum;
            int rightNums = a_pagesNum - a_curPageNum;
            int rightSlots = a_pageSetSize / 2;
            int leftSlots = rightSlots + a_pageSetSize % 2;

            int tail = rightNums - rightSlots;
            if (tail < 0)
            {
                leftSlots -= tail;
            }
            else
            {
                tail = leftNums - leftSlots;
                if (tail < 0)
                {
                    rightSlots -= tail;
                }
            }

            int[] result = new int[a_pageSetSize];

            int slotNum = 0;
            for (int idx = (a_pageSetSize > 2) ? 1 : a_curPageNum - leftSlots + 1; idx <= a_pagesNum && slotNum < a_pageSetSize; idx++)
            {
                if (idx <= a_curPageNum)
                {
                    if ((1 == idx && a_pageSetSize > 4) ||
                        (idx >= a_curPageNum - (leftSlots - 1)))
                    {
                        result[slotNum] = idx;
                    }
                    else
                    {
                        result[slotNum] = (slotNum > 0) ? -((a_curPageNum - (leftSlots - 2)) / 2) : -1;
                        idx = a_curPageNum - (leftSlots - 2) - 1;
                    }
                    leftSlots--;
                }
                else
                {
                    if ((rightNums - rightSlots <= 0) ||
                        (idx <= a_curPageNum + (rightSlots - 2)) ||
                        (idx == a_pagesNum))
                    {
                        result[slotNum] = idx;
                    }
                    else if (idx < a_pagesNum)
                    {
                        result[slotNum] = (slotNum < a_pageSetSize - 1) ? -(idx + (a_pagesNum - idx) / 2) : -a_pagesNum;
                        idx = a_pagesNum - (a_pageSetSize - slotNum - 1);
                    }
                }
                slotNum++;
            }

            return result;
        }

Answer 2

对于少量页面来说可能有点过分了，但是对于对非常大的数据集进行分页，请考虑此处描述的对数技术。 我在 PHP 和（经典）ASP 中发布了相关算法，但转换为 ASP.NET 会很容易。