C# 使用C在MongoDB中分页数据时的分组结果#

我是一个初级开发人员，我需要这方面的帮助。 我工作的结构如下：

public class Log// : MongoEntity
{
    public ObjectId Id { get; set; }
    public string Guid { get; set; }
    public DateTime Date { get; set; }
    public string AdditionalInfo { get; set; }
    public string MethodAndClass { get; set; }
    public int ThreadId { get; set; }
    public string[] Message { get; set; }
    [BsonRepresentation(BsonType.String)]
    public short Level { get; set; }
}
public class LogGroup {
    [BsonId]
    public string Guid { get; set; }
    public List<Log> Logs { get; set; }   
}

public class LogResult : PagingFilter
{
    public List<Log> Logs { get; set; }
}

public class PagingFilter : Filter
{
    public int PageNumber { get; set; }
    public int PageSize { get; set; }
    public int PageCount { get; set; }
    public long TotalRows { get; set; }
    public bool UsePagingFilter { get; set; }
}


public class Filter
{
    public DateTime? start { get; set; }
    public DateTime? end { get; set; }
    public string textToSearch { get; set; }
    public string timeZone { get; set; }
}

公共类日志//：MongoEntity
{
公共对象Id{get；set；}
公共字符串Guid{get；set；}
公共日期时间日期{get；set；}
公共字符串附加信息{get；set；}
公共字符串方法和类{get；set；}
public int ThreadId{get；set；}
公共字符串[]消息{get；set；}
[BsonRepresentation（BsonType.String）]
公共短级别{get；set；}
}
公共类日志组{
[BsonId]
公共字符串Guid{get；set；}
公共列表日志{get；set；}
}
公共类日志结果：PagingFilter
{
公共列表日志{get；set；}
}
公共类分页筛选器：筛选器
{
公共整数页码{get；set；}
公共int PageSize{get；set；}
public int PageCount{get；set；}
公共长TotalRows{get；set；}
公共bool UsePagingFilter{get；set；}
}
公共类过滤器
{
公共日期时间？开始{get；set；}
公共日期时间？结束{get；set；}
公共字符串textToSearch{get；set；}
公共字符串时区{get；set；}
}

在早期版本的mongo驱动程序中，实现返回的日志分组如下：

var aggregateLogs = GetCollection().Aggregate(new AggregateOptions { AllowDiskUse = true }).Match(filter)
    .Group(new BsonDocument { { "_id", "$Guid" }, { "Logs", new BsonDocument("$push", "$$ROOT") } });

List<LogGroup> logs = new List<LogGroup>();
logs.AddRange(aggregateLogs.ToList().Select(x => BsonSerializer.Deserialize<LogGroup>(x)));
return logs;

var aggregateLogs=GetCollection（）.Aggregate（新的聚合选项{AllowDiskUse=true}）.匹配（筛选器）
.Group（新的BsonDocument{{{u id'，“$Guid”}，{“Logs”，新的BsonDocument（“$push”，“$$ROOT”）}）；
列表日志=新列表（）；
logs.AddRange（aggregateLogs.ToList（）.Select（x=>BsonSerializer.Deserialize（x））；
返回日志；

但是由于日志太多，系统返回了一个异常。 现在，基于，我更新了驱动程序，以便能够通过分页实现这一点，如下所示：

var countFacet = AggregateFacet.Create("count",
    PipelineDefinition<Log, AggregateCountResult>.Create(new[]
    {
        PipelineStageDefinitionBuilder.Count<Log>()
    }));


var dataFacet = AggregateFacet.Create("data",
    PipelineDefinition<Log, BsonDocument>.Create(new[]
    {    
        PipelineStageDefinitionBuilder.Sort(Builders<Log>.Sort.Descending(x => x.Date)),
        PipelineStageDefinitionBuilder.Skip<Log>((currentPage - 1) * pageSize),
        PipelineStageDefinitionBuilder.Limit<Log>(pageSize)
    }));
    
var collection = GetCollection();

var aggregation = await collection.Aggregate(new AggregateOptions { AllowDiskUse = true })
    .Match(filter)
    .Facet(countFacet,dataFacet)
    .ToListAsync();
    
var count = aggregation.First()
    .Facets.First(x => x.Name == "count")
    .Output<AggregateCountResult>()
    .First()
    .Count;
    
var totalPagesDecimal = count / (decimal)pageSize;
var decimalValue = (totalPagesDecimal % 1) * 10;
if (decimalValue > 0)
    totalPagesDecimal++;

var totalPages = (int)totalPagesDecimal;

var data = aggregation.First()
            .Facets.First(x => x.Name == "data")
            .Output<Log>();

List<Log> logs = new List<Log>();
logs.AddRange(data.ToList());   

logResult.Logs = logs;
logResult.TotalRows = totalPages;
logResult.PageNumber = currentPage;
logResult.PageSize = pageSize;
logResult.Count = count;
return logResult;

var countFacet=AggregateFacet.Create（“count”，
PipelineDefinition.Create（新建[]
{
PipelineStageDefinitionBuilder.Count（）
}));
var dataFacet=AggregateFacet.Create（“数据”，
PipelineDefinition.Create（新建[]
{    
PipelineStageDefinitionBuilder.Sort（Builders.Sort.Descending（x=>x.Date）），
PipelineStageDefinitionBuilder.Skip（（当前页面-1）*页面大小），
PipelineStageDefinitionBuilder.Limit（页面大小）
}));
var collection=GetCollection（）；
var aggregation=await collection.Aggregate（新聚合选项{AllowDiskUse=true}）
.Match（过滤器）
.Facet（countFacet、dataFacet）
.ToListAsync（）；
var count=aggregation.First（）
.Facets.First（x=>x.Name==“count”）
.产出

我需要将结果分组，条件与我在上一版本中使用的条件相同：

var aggregateLogs = GetCollection().Aggregate(new AggregateOptions { AllowDiskUse = true }).Match(filter) .Group(new BsonDocument { { "_id", "$Guid" }, { "Logs", new BsonDocument("$push", "$$ROOT") } });
List<LogGroup> logs = new List<LogGroup>();
logs.AddRange(aggregateLogs.ToList().Select(x => BsonSerializer.Deserialize<LogGroup>(x)));
return logs;

var aggregateLogs=GetCollection（）.Aggregate（新的AggregateOptions{AllowDiskUse=true}）.Match（filter）.Group（新的BsonDocument{{{{{u id'，“$Guid”}，{“Logs”，新的BsonDocument（$push'，“$$ROOT”）}）；
列表日志=新列表（）；
logs.AddRange（aggregateLogs.ToList（）.Select（x=>BsonSerializer.Deserialize（x））；
返回日志；


有没有一种方法可以通过刻面来实现这一点