在asp核心中使用筛子进行分页时如何发送单个请求而不是两个请求？

Question

我编写此查询的目的是让用户进行分页。我正在使用Sieve 进行分页、过滤和排序，但我对这个查询有疑问：

我打算向数据库发送一个请求，然后将这些数据返回给我：

 public class UserPagingDto
{
    [Sieve(CanFilter = true, CanSort = true)]
    public Guid Id { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public string Username { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public string DisplayName { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public bool IsActive { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public bool IsLockedEnd { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public bool ConfirmPhoneNumber { get; set; }
    public UserPagingInfo UserInfos { get; set;
    }
}

public class UserPagingInfo
{
    [Sieve(CanFilter = true, CanSort = true)]
    public int AccountFaile { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public bool ConfirmEmail { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public string PhoneNumber { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public DateTimeOffset? LockedEnd { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public string? Email { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public string Name { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public string Family { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public string RoleName { get; set; }
    [Sieve(CanFilter = true, CanSort = true)]
    public Guid RoleId { get; set; }

}

出于这个目的，我写了这个：

    var user = Users.AsNoTracking().Select(x => new
            {
                Id=x.Id,
                Username = x.Username,
                Name = x.Name,
                Family = x.Family,
                DisplayName = $"{x.Name} {x.Family}",
                Email = x.Email,
                PhoneNumber = x.PhoneNumber,
                AccountFaile = x.AccountFaile,
                IsActive = x.IsActive,
                IsLockedEnd = x.IsLockedEnd,
                ConfirmPhoneNumber = x.ConfirmPhoneNumber,
                ConfirmEmail = x.ConfirmEmail,
                LockedEnd = x.LockedEnd,
                Role = x.UserRoles.Role
            }).Select(c => new UserPagingDto
            {
                Id=c.Id,
                ConfirmPhoneNumber = c.ConfirmPhoneNumber,
                DisplayName = c.DisplayName,
                IsActive = c.IsActive,
                IsLockedEnd = c.IsLockedEnd,
                Username = c.Username,
                UserInfos = new UserPagingInfo
                {
                    AccountFaile = c.AccountFaile,
                    ConfirmEmail = c.ConfirmEmail,
                    Email = c.Email,
                    Family = c.Family,
                    LockedEnd = c.LockedEnd,
                    Name = c.Name,
                    PhoneNumber = c.PhoneNumber,
                    RoleId = c.Role.Id,
                    RoleName = c.Role.Name
                }
            });
            var sieveModel = new SieveModel
            {
                PageSize = formQuery.PageSize,
                Filters = formQuery.Filters,
                Page = formQuery.Page,
                Sorts = formQuery.Sorts
            };
            var result = sieveProcessor.Apply(sieveModel, user);
            return OperationResult<GetAllPaging<UserPagingDto>>.BuildSuccessResult(new GetAllPaging<UserPagingDto>
            {
                Records = result,
                TotalCount = await Users.CountAsync()
            });

但它向数据库发送两个请求，效果不好。我想通过发送一个请求来达到相同的结果。

我使用分析器跟踪对数据库的查询。

一个查询是这样的：

    SELECT COUNT(*)
    FROM [User] AS [u]
         WHERE [u].[IsDelete] = CAST(0 AS bit)

第二个查询是这样的，我打算只发送这个查询：

 SELECT [u].[Id], [u].[ConfirmPhoneNumber], [u].[Name], [u].[Family], [u].[IsActive], [u].[IsLockedEnd], [u].[Username], [u].[AccountFaile], [u].[ConfirmEmail], [u].[Email], [u].[LockedEnd], [u].[PhoneNumber], [t0].[Id], [t0].[Name]
FROM [User] AS [u]
LEFT JOIN (
    SELECT [u0].[Id], [u0].[IsDelete], [u0].[RoleId], [u0].[UserId]
    FROM [UserRole] AS [u0]
    WHERE [u0].[IsDelete] = CAST(0 AS bit)
) AS [t] ON [u].[Id] = [t].[UserId]
LEFT JOIN (
    SELECT [r].[Id], [r].[Description], [r].[IsDelete], [r].[Name], [r].[SecurityStamp]
    FROM [Role] AS [r]
    WHERE [r].[IsDelete] = CAST(0 AS bit)
) AS [t0] ON [t].[RoleId] = [t0].[Id]
WHERE [u].[IsDelete] = CAST(0 AS bit)
ORDER BY [u].[Id]
OFFSET @__p_0 ROWS FETCH NEXT @__p_1 ROWS ONLY

Answer 1

您混淆了查询和集合。

这个：

var user = Users.AsNoTracking().Select(x => new
            {
   . . .
                    RoleId = c.Role.Id,
                    RoleName = c.Role.Name
                }
            });

不是对象的集合。这是一个查询。如果您将查询传递给运行.Count() 和.ToList() 的方法，您将运行两个不同的查询。

所以只需运行一次查询，并将结果存储在一个列表中。例如：

var userQuery = Users.AsNoTracking().Select(x => new
            {
   . . .
                    RoleId = c.Role.Id,
                    RoleName = c.Role.Name
                }
            });
 var user = userQuery.ToList();

Answer 2

让我们稍微考虑一下。您有一张表，假设有 100 000 000 条记录。过滤并应用分页设置后，您的查询以一页记录结束，假设有 100 个这样的项目。从项目数（示例中为 100）中，您无法推断总数（示例中为 100 000 000）。如果我们看一下这些字段，这些字段都没有给出任何关于记录总数的提示。为所有记录的计数添加一列将是一个非常糟糕的主意。

因此，如果我们保持合理，那么我们承认您打算作为唯一查询的查询不会向您提供有关计数的任何信息。要解决这种情况，您需要将该计数存储为server variable。如果您以这种方式缓存计数，那么您将能够使用该服务器变量并随时重用它，而不是在每次加载时硬计算它。但是，为了确保它运行良好，您需要保持该值：

• 每当插入这样的记录时，增加服务器上的计数值
• 每当删除此类记录时，减少服务器上的计数值
• 每当取消删除此类记录时，增加服务器上的计数值
• 当然，如果发生批量插入、删除或取消删除，则需要相应地更改计数
• 您还需要一个心跳任务来确保您拥有的服务器变量与实际计数同步，因为记录也可以在您的应用程序之外创建/删除/更新，至少通过在数据库