我应该使用 LINQ 的 Skip() 和 Take() 方法进行分页，还是使用 SQL 查询实现我自己的分页？
哪个最有效？为什么我会选择一个而不是另一个？
我正在使用 SQL Server 2008、ASP.NET MVC 和 LINQ。
【问题讨论】：
标签： sql sql-server asp.net-mvc linq-to-sql pagination
试图简要回答您的疑问，如果您在 linq 上执行 skip(n).take(m) 方法（使用 SQL 2005 / 2008 作为数据库服务器），您的查询将使用 Select ROW_NUMBER() Over ... 语句，以某种方式直接分页在 SQL 引擎中。
举个例子，我有一个名为 mtcity 的 db 表，我编写了以下查询（也适用于 linq to entity）：
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 Server 中获取从 501 到 600 的行，而不将它们加载到内存中。请注意，此语法仅适用于 SQL Server 2012
【讨论】：
虽然 LINQ-to-SQL 将生成 OFFSET 子句（可能使用 ROW_NUMBER() OVER() as others have mentioned 模拟），但在 SQL 中执行分页的方式完全不同，而且速度更快。这通常称为this blog post here 中描述的“seek 方法”。
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。
skip/take 方法对我和其他人都非常有效。
出于好奇，您有什么类型的自分页查询，您认为比 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'
【讨论】：
sp_executesql，您可以以安全的方式传递参数，例如：EXECUTE sp_executesql 'WITH myCTE AS ... WHERE Col4=@p1) ...', '@p1 nvarchar(max)', @ValueForCol4。在这种情况下安全意味着它对 SQL 注入很健壮 - 您可以在变量 @ValueForCol4 中传递所有可能的值 - 甚至是 '--'，查询仍然有效！
SELECT ROW_NUMBER() OVER (ORDER BY CASE WHEN @CampoId = 1 THEN Id WHEN @CampoId = 2 THEN field2 END)
ROW_NUMBER() OVER() 偏移仿真快得多。另见：4guysfromrolla.com/webtech/042606-1.shtml
在 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]
在 t0 中是所有记录 在 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 的回答真的很有帮助。
谢谢
【讨论】：
@p0 更具体地说是@p1 来自哪里
你可以通过传递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();
【讨论】：