[英]Dapper. Paging
我正在尝试 Dapper ORM，我正在查询一个 Posts 表。
但我想获得分页结果......
1 - 我该怎么做？ 这个没有帮手吗？
2 - Dapper Query 可以返回 IQueryable 吗？
谢谢你，米格尔
您没有指定数据库或版本。 如果您有幸能够使用全新的 SQL Server 2012 并访问 MSDN，则可以使用闪亮的新OFFSET和FETCH关键字。 以下查询将跳过 20 条记录并返回接下来的 5 条记录。
SELECT * FROM [Posts]
ORDER BY [InsertDate]
OFFSET 20 ROWS
FETCH NEXT 5 ROWS ONLY
查看http://msdn.microsoft.com/en-us/library/ms188385(v=sql.110).aspx#Offset了解更多信息。
此外，复制 Massive 的方式并为 IDbConnection 编写自己的扩展方法也很容易。 这是 Massive 的代码。
var query = string.Format("SELECT {0} FROM (SELECT ROW_NUMBER() OVER (ORDER BY {2}) AS Row, {0} FROM {3} {4}) AS Paged ", columns, pageSize, orderBy, TableName, where);
1) Dapper 没有内置的分页功能。 但是在查询中直接实现它并不难。 例子：
SELECT *
FROM ( SELECT ROW_NUMBER() OVER ( ORDER BY InsertDate) AS RowNum, *
FROM Posts
WHERE InsertDate >= '1900-01-01'
) AS result
WHERE RowNum >= 1 // *your pagination parameters
AND RowNum < 20 //*
ORDER BY RowNum
需要 SQL Server 2005+
2) Dapper 返回一个IEnumerable<T> 。
这是使用 C# 和 Dapper 的完整工作版本。
/// <summary>
/// Gets All People
/// </summary>
/// <returns>List of People</returns>
public IEnumerable<Person> GetAllPeople(Pager pager)
{
var sql = (@" select * from [dbo].[Person]
order by [PeplNo]
OFFSET @Offset ROWS
FETCH NEXT @Next ROWS ONLY");
using (IDbConnection cn = Connection)
{
cn.Open();
var results = cn.Query<Person>(sql,pager);
return results;
}
}
public class Pager
{
public int Page { get; set; }
public int PageSize { get; set; }
public int Offset { get; set; }
public int Next { get; set; }
public Pager(int page, int pageSize = 10)
{
Page = page < 1 ? 1 : page;
PageSize = pageSize < 1 ? 10 : pageSize;
Next = pageSize;
Offset = (Page - 1) * Next;
}
}
我创建了一个示例项目来演示 Dapper 自定义分页，支持排序、条件和过滤器：
https://github.com/jinweijie/Dapper.PagingSample
基本上，该方法如下所示：
Tuple<IEnumerable<Log>, int> Find(LogSearchCriteria criteria
, int pageIndex
, int pageSize
, string[] asc
, string[] desc);
第一个返回值是项目列表。 第二个返回值是总计数。
希望能帮助到你。
谢谢。
public async Task<IEnumerable<Blog>> GetBlogs(int pageNo = 1, int pageSize = 10)
{
int skip = (pageNo - 1) * pageSize;
using (var db = _context.GetOpenConnection())
{
var query = string.Format(@"SELECT * FROM [blog] ORDER BY [Id] OFFSET {0} ROWS FETCH NEXT {1} ROWS ONLY", skip, pageSize);
var result = await db.QueryAsync<Blog>(query);
return result;
}
}
我创建了一个具有强类型参数的泛型方法来获得可重用的解决方案。 这依赖于 FETCH NEXT 和 OFFSET，这意味着您需要 SQL Server 2012 或更新版本。
/// <summary>
/// Fetches page with page number <paramref name="pageNumber"/> with a page size set to <paramref name="pageSize"/>.
/// Last page may contains 0 - <paramref name="pageSize"/> items. The page number <paramref name="pageNumber"/> is 0-based,
/// i.e starts with 0. The method relies on the 'FETCH NEXT' and 'OFFSET' methods
/// of the database engine provider.
/// Note: When sorting with <paramref name="sortAscending"/> set to false, you will at the first page get the last items.
/// The parameter <paramref name="orderByMember"/> specified which property member to sort the collection by. Use a lambda.
/// </summary>
/// <typeparam name="T">The type of ienumerable to return and strong type to return upon</typeparam>
/// <param name="connection">IDbConnection instance (e.g. SqlConnection)</param>
/// <param name="orderByMember">The property to order with</param>
/// <param name="sql">The select clause sql to use as basis for the complete paging</param>
/// <param name="pageNumber">The page index to fetch. 0-based (Starts with 0)</param>
/// <param name="pageSize">The page size. Must be a positive number</param>
/// <param name="sortAscending">Which direction to sort. True means ascending, false means descending</param>
/// <returns></returns>
public static IEnumerable<T> GetPage<T>(this IDbConnection connection, Expression<Func<T, object>> orderByMember,
string sql, int pageNumber, int pageSize, bool sortAscending = true)
{
if (string.IsNullOrEmpty(sql) || pageNumber < 0 || pageSize <= 0)
{
return null;
}
int skip = Math.Max(0, (pageNumber)) * pageSize;
if (!sql.Contains("order by", StringComparison.CurrentCultureIgnoreCase))
{
string orderByMemberName = GetMemberName(orderByMember);
sql += $" ORDER BY [{orderByMemberName}] {(sortAscending ? "ASC": " DESC")} OFFSET @Skip ROWS FETCH NEXT @Next ROWS ONLY";
return connection.ParameterizedQuery<T>(sql, new Dictionary<string, object> { { "@Skip", skip }, { "@Next", pageSize } });
}
else
{
sql += $" OFFSET @Skip ROWS FETCH NEXT @Next ROWS ONLY";
return connection.ParameterizedQuery<T>(sql, new Dictionary<string, object> { { "@Skip", skip }, { "@Next", pageSize } });
}
}
下面的支持方法，获取属性名称和运行参数化查询。
private static string GetMemberName<T>(Expression<Func<T, object>> expression)
{
switch (expression.Body)
{
case MemberExpression m:
return m.Member.Name;
case UnaryExpression u when u.Operand is MemberExpression m:
return m.Member.Name;
default:
throw new NotImplementedException(expression.GetType().ToString());
}
}
public static IEnumerable<T> ParameterizedQuery<T>(this IDbConnection connection, string sql,
Dictionary<string, object> parametersDictionary)
{
if (string.IsNullOrEmpty(sql))
{
return null;
}
string missingParameters = string.Empty;
foreach (var item in parametersDictionary)
{
if (!sql.Contains(item.Key))
{
missingParameters += $"Missing parameter: {item.Key}";
}
}
if (!string.IsNullOrEmpty(missingParameters))
{
throw new ArgumentException($"Parameterized query failed. {missingParameters}");
}
var parameters = new DynamicParameters(parametersDictionary);
return connection.Query<T>(sql, parameters);
}
使用 Northwind DB 的示例用法：
var sql = $"select * from products";
var productPage = connection.GetPage<Product>(m => m.ProductID, sql, 0, 5, sortAscending: true);
示例 POCO 如下所示：
public class Product
{
public int ProductID { get; set; }
public string ProductName { get; set; }
public int? SupplierID { get; set; }
public int? CategoryID { get; set; }
public string QuantityPerUnit { get; set; }
public decimal? UnitPrice { get; set; }
public short? UnitsInStock { get; set; }
public short? UnitsOnOrder { get; set; }
public short? ReorderLevel { get; set; }
public bool? Discontinued { get; set; }
}
这种方法的一个更深入的变体也可以构建一种方法来使用 DB Cursor 获取 IEnumerables 的 IEnumerable 并包装这里使用的逻辑，但我的方法是一个坚固的可预测类型安全解决方案的基本演示，而不依赖于更灵活的动态方法。 不利的一面是，由于我们有通用参数，我们还必须为我们的数据库类编写 POCO，并不是所有的开发人员都喜欢花时间在这上面。
如果你想在 dapper 中使用分页，你可以使用 OFFSET 和 FETCH。 我使用存储过程。 首先在 Sql 中键入此查询并创建您的过程：
CREATE procedure SpName
@OFFSET int
as begin
select * from TableName
where (if you have condit)
order by columnName
OFFSET @OFFSET ROWS
FETCH NEXT 25(display 25 rows per page) ROWS ONLY
end;
然后您在代码中创建了使用 dapper 和 storeProcedure 获取数据的方法：
public async Task<List<T>> getAllData<T>(string spName, DynamicParameters param)
{
try
{
using (var con = new SqlConnection(_connections.DefaultConnection))
{
var result = await con.QueryAsync<T>(spName, param, commandType: System.Data.CommandType.StoredProcedure);
return result.ToList();
}
}
catch (Exception ex)
{
//
}
}
然后和最终你调用存储过程并在你想要使用 dapper 的每个方法中设置参数（@OFFSET）：
public async Task<List<YourModel>> methodName (int offset)
{
var param = new DynamicParameters();
param.Add("@OFFSET" , offset);
var data = await getAllData<yourModel>("spName", param);
var result = _mapper.Map<List<yourModel>>(data);
return result;
}
我发现此解决方案适合我。 它还添加了排序。
public async Task<PagedCustomerResult> GetPagedCustomersAsync(string? sortBy = null, string? sortOrder = null, string pageNumber = 0, string pageSize = 0)
{
var param = new
{
offSet = (pageNumber -1) * pageSize,
pageSize
};
// First query to get total number of records
StringBuilder sb = new StringBuilder(@"SELECT COUNT(0) [Count] from Customers;");
// Second query to get the data
sb.AppendLine(@" SELECT * from Customers c");
if (sortBy != null && sortOrder != null)
{
sb.AppendLine($" ORDER BY {BuildOrderBySqlUsingIntepolation(sortBy, sortOrder)}");
}
if (pageNumber > 0 && pageSize > 0)
{
sb.AppendLine(@" OFFSET @OffSet ROWS FETCH NEXT @PageSize ROWS ONLY");
}
var multi = await sqlConnection.QueryMultipleAsync(sb.ToString(), param);
var totalRowCount = await multi.ReadSingleAsync<int>();
var customers = await multi.ReadAsync<Customer>();
return new PagedCustomerResult(customers, pageNumber, pageSize, totalRowCount);
}
public class PagedCustomerResult
{
private IEnumerable<Customer> _data;
private int _currentPage;
private int _pageSize;
private int _totalRecords;
private int _totalPages;
public PagedCustomerResult(IEnumerable<Customer> data, int page, int pageSize, int totalRecords)
{
_data = data;
_currentPage = page;
_pageSize = pageSize;
_totalRecords = totalRecords;
_totalPages = (int)Math.Ceiling(totalRecords / (double)pageSize);
}
public IEnumerable<Customer> Data => _data;
public int CurrentPage => _currentPage;
public int PageSize => _pageSize;
public int TotalRecords => _totalRecords;
public int TotalPages => _totalPages;
}
private static string BuildOrderBySqlUsingIntepolation(string sortOrderColumn, string sortOrderDirection)
{
string orderBy;
switch (sortOrderColumn)
{
case "name":
orderBy = "c.[Name]";
break;
default:
orderBy = "c.[CreatedDateTime]";
break;
}
if (!string.IsNullOrEmpty(sortOrderDirection))
{
var sortOrder = "asc";
if (sortOrderDirection == "desc")
{
sortOrder = "desc";
}
orderBy = $"{orderBy} {sortOrder}";
}
return orderBy;
}
如果您没有 Sql Server 2012 或您有其他 DBMS，进行分页的一种方法是在 DBMS 和 Web 服务器或客户端之间拆分处理。 ---这仅推荐用于小尺寸。 您可以使用Sql Server 中的'TOP' 关键字或MySql 中的LIMIT 或Oracle 中的ROWNUM 来获取数据集中的最高行数。 您将提取的行数等于您将跳过的数量加上您将采用的数量：
top = skip + take;
例如，您想跳过 100 行并取下 50 行：
top = 100 + 50
所以你的 SQL 语句看起来像这样（SQL 服务器风格）
SELECT TOP 150 Name, Modified, content, Created
FROM Posts
WHERE Created >= '1900-01-01'
在客户端上：如果您使用 C# 等 .NET 语言并使用 Dapper，则可以使用 linq 跳过多行并获取多行，如下所示：
var posts = connection.Query<Post>(sqlStatement, dynamicParameters);
return posts?.ToList().Skip(skipValue).Take(takeValue);
ASP.net Core 3.1 Razor 页面分页控件不适用于 dapper 数据集
[英]ASP.net Core 3.1 Razor page Paging control not working with dapper dataset
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.