实现分页的有效方法

试图简要回答您的疑问，如果您在 linq 上执行 skip(n).take(m) 方法（使用 SQL 2005 / 2008 作为数据库服务器），您的查询将使用 Select ROW_NUMBER() Over ... 语句，在 SQL 中以某种方式直接分页引擎。

举个例子，我有一个名为 mtcity 的数据库表，我编写了以下查询（与 linq 到实体一起工作）：

using (DataClasses1DataContext c = new DataClasses1DataContext())
{
    var query = (from MtCity2 c1 in c.MtCity2s
                select c1).Skip(3).Take(3);
    //Doing something with the query.
}

结果查询将是：

SELECT [t1].[CodCity], 
    [t1].[CodCountry], 
    [t1].[CodRegion], 
    [t1].[Name],  
    [t1].[Code]
FROM (
    SELECT ROW_NUMBER() OVER (
        ORDER BY [t0].[CodCity], 
        [t0].[CodCountry], 
        [t0].[CodRegion], 
        [t0].[Name],
        [t0].[Code]) AS [ROW_NUMBER], 
        [t0].[CodCity], 
        [t0].[CodCountry], 
        [t0].[CodRegion], 
        [t0].[Name],
        [t0].[Code]
    FROM [dbo].[MtCity] AS [t0]
    ) AS [t1]
WHERE [t1].[ROW_NUMBER] BETWEEN @p0 + 1 AND @p0 + @p1
ORDER BY [t1].[ROW_NUMBER]

这是一个窗口数据访问（很酷，顺便说一句，因为从一开始就会返回数据，并且只要满足条件就会访问表）。这将非常类似于：

With CityEntities As 
(
    Select ROW_NUMBER() Over (Order By CodCity) As Row,
        CodCity //here is only accessed by the Index as CodCity is the primary
    From dbo.mtcity
)
Select [t0].[CodCity], 
        [t0].[CodCountry], 
        [t0].[CodRegion], 
        [t0].[Name],
        [t0].[Code]
From CityEntities c
Inner Join dbo.MtCity t0 on c.CodCity = t0.CodCity
Where c.Row Between @p0 + 1 AND @p0 + @p1
Order By c.Row Asc

例外的是，第二个查询将比 linq 结果执行得更快，因为它将专门使用索引来创建数据访问窗口；这意味着，如果您需要一些过滤，过滤应该（或必须）在实体列表（创建行的位置）中，并且还应该创建一些索引以保持良好的性能。

现在，有什么更好的？

如果您的逻辑中有非常可靠的工作流程，那么实现正确的 SQL 方式将很复杂。在这种情况下，LINQ 将是解决方案。

如果您可以将那部分逻辑直接降低到 SQL（在存储过程中），那就更好了，因为您可以实现我向您展示的第二个查询（使用索引）并允许 SQL 生成和存储查询（提高性能）。

---

尝试使用

FROM [TableX]
ORDER BY [FieldX]
OFFSET 500 ROWS
FETCH NEXT 100 ROWS ONLY

在 SQL 服务器中获取从 501 到 600 的行，而不将它们加载到内存中。请注意，此语法仅适用于 SQL Server 2012

---

虽然 LINQ-to-SQL 将生成一个 OFFSET 子句（可能使用 ROW_NUMBER() OVER() as others have mentioned 模拟），但在 SQL 中执行分页有一种完全不同的更快的方法。这通常称为 this blog post here 中描述的“搜索方法”。

SELECT TOP 10 first_name, last_name, score
FROM players
WHERE (score < @previousScore)
   OR (score = @previousScore AND player_id < @previousPlayerId)
ORDER BY score DESC, player_id DESC

@previousScore 和 @previousPlayerId 值分别是上一页最后一条记录的值。这允许您获取“下一页”。如果 ORDER BY 方向是 ASC，只需使用 > 代替。

使用上述方法，您不能在没有先获取前 40 条记录的情况下立即跳转到第 4 页。但通常，无论如何你都不想跳那么远。相反，您将获得更快的查询，该查询可能能够在恒定时间内获取数据，具体取决于您的索引。另外，您的页面保持“稳定”，无论基础数据是否发生变化（例如，在第 1 页，而您在第 4 页）。

例如，当在 Web 应用程序中延迟加载更多数据时，这是实现分页的最佳方式。

请注意，“seek 方法”也称为 keyset paging。

---

LinqToSql 会自动为您将 .Skip(N1).Take(N2) 转换为 TSQL 语法。事实上，你在 Linq 中所做的每一个“查询”，实际上只是在后台为你创建一个 SQL 查询。要对此进行测试，只需在应用程序运行时运行 SQL Profiler。

跳过/采取方法对我和我所读到的其他人都非常有效。

出于好奇，您有什么类型的自分页查询，您认为它比 Linq 的跳过/获取更有效？

---

我们在存储过程中使用包装在动态 SQL 中的 CTE（因为我们的应用程序需要对数据服务器端进行动态排序）。如果您愿意，我可以提供一个基本示例。

我还没有机会查看 LINQ 生成的 T/SQL。有人可以发布样本吗？

我们不使用 LINQ 或直接访问表，因为我们需要额外的安全层（假设动态 SQL 在某种程度上打破了这一点）。

像这样的东西应该可以解决问题。您可以为参数等添加参数化值。

exec sp_executesql 'WITH MyCTE AS (
    SELECT TOP (10) ROW_NUMBER () OVER ' + @SortingColumn + ' as RowID, Col1, Col2
    FROM MyTable
    WHERE Col4 = ''Something''
)
SELECT *
FROM MyCTE
WHERE RowID BETWEEN 10 and 20'

---

在 SQL Server 2008 中：

DECLARE @PAGE INTEGER = 2
DECLARE @TAKE INTEGER = 50

SELECT [t1].*
FROM (
    SELECT ROW_NUMBER() OVER (ORDER BY [t0].[COLUMNORDER] DESC) AS [ROW_NUMBER], [t0].*
    FROM [dbo].[TABLA] AS [t0]
    WHERE ([t0].[COLUMNS_CONDITIONS] = 1)
    ) AS [t1]
WHERE [t1].[ROW_NUMBER] BETWEEN ((@PAGE*@TAKE) - (@TAKE-1)) AND (@PAGE*@TAKE)
ORDER BY [t1].[ROW_NUMBER]

In t0 是所有记录 In t1 只是那些对应于该页面的记录

---

我给出的方法是 SQL Server 可以实现的最快的分页。我已经在 500 万条记录上对此进行了测试。这种方式比SQL Server提供的“OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY”要好很多。

-- The below given code computes the page numbers and the max row of previous page
-- Replace <<>> with the correct table data.
-- Eg. <<IdentityColumn of Table>> can be EmployeeId and <<Table>> will be dbo.Employees

DECLARE @PageNumber int=1; --1st/2nd/nth page. In stored proc take this as input param.
DECLARE @NoOfRecordsPerPage int=1000;

 DECLARE @PageDetails TABLE
       (
        <<IdentityColumn of Table>> int,
        rownum int,
        [PageNumber] int
       )           
       INSERT INTO @PageDetails values(0, 0, 0)
       ;WITH CTE AS
       (
       SELECT <<IdentityColumn of Table>>, ROW_NUMBER() OVER(ORDER BY <<IdentityColumn of Table>>) rownum FROM <<Table>>
       )
       Insert into @PageDetails 
       SELECT <<IdentityColumn of Table>>, CTE.rownum, ROW_NUMBER() OVER (ORDER BY rownum) as [PageNumber] FROM CTE WHERE CTE.rownum%@NoOfRecordsPerPage=0


--SELECT * FROM @PageDetails 

-- Actual pagination
SELECT TOP (@NoOfRecordsPerPage)
FROM <<Table>> AS <<Table>>
WHERE <<IdentityColumn of Table>> > (SELECT <<IdentityColumn of Table>> FROM 
@PageDetails WHERE PageNumber=@PageNumber)
ORDER BY <<Identity Column of Table>>

---

你可以进一步提高性能，检查这个

From CityEntities c
Inner Join dbo.MtCity t0 on c.CodCity = t0.CodCity
Where c.Row Between @p0 + 1 AND @p0 + @p1
Order By c.Row Asc

如果您以这种方式使用 from ，它将提供更好的结果：

From   dbo.MtCity  t0
   Inner Join  CityEntities c on c.CodCity = t0.CodCity

原因：因为您在 CityEntities 表上使用 where 类，这将在加入 MtCity 之前消除许多记录，所以 100% 肯定它会提高性能许多倍...

无论如何，rodrigoelp 的回答真的很有帮助。

谢谢

---

您可以通过传递 PageIndex 以这种简单的方式实现分页

Declare @PageIndex INT = 1
Declare  @PageSize INT = 20

Select ROW_NUMBER() OVER ( ORDER BY Products.Name ASC )  AS RowNumber,
    Products.ID,
    Products.Name
into #Result 
From Products

SELECT @RecordCount = COUNT(*) FROM #Results 

SELECT * 
FROM #Results
WHERE RowNumber
BETWEEN
    (@PageIndex -1) * @PageSize + 1 
    AND
    (((@PageIndex -1) * @PageSize + 1) + @PageSize) - 1

---

在 2008 年我们不能使用 Skip().Take()

方法是：

var MinPageRank = (PageNumber - 1) * NumInPage + 1
var MaxPageRank = PageNumber * NumInPage

var visit = Visita.FromSql($"SELECT * FROM (SELECT [RANK] = ROW_NUMBER() OVER (ORDER BY Hora DESC),* FROM Visita WHERE ) A WHERE A.[RANK] BETWEEN {MinPageRank} AND {MaxPageRank}").ToList();

---