最新版本MongoC#驱动程序的聚合函数问题

我有一个使用MongoDB的.NET应用程序。我目前使用的驱动程序是1.9.2。我正在尝试将其升级到2.7.0

我在使聚合查询在新版本中工作时遇到一些困难：

驱动程序版本1.9.2中的工作代码为：

    public IEnumerable<Car> GetCarsModifiedInPeriod(DateTimeOffset dateFrom, DateTimeOffset dateTo)
    {
        var matchRequestFromDate = new BsonDocument
        {
            {
                "$match",
                new BsonDocument
                {
                    {
                        // Filter out those too recently modified
                       "LastUpdatedOn.0", new BsonDocument {{"$gte", dateFrom.Ticks}}
                    }
                }
            }
        };
        var matchRequestToDate = new BsonDocument
        {
            {
                "$match",
                new BsonDocument
                {
                    {
                        // Filter out those too recently modified
                        "LastUpdatedOn.0", new BsonDocument {{"$lte", dateTo.Ticks}}
                    }
                }
            }
        };

        var cars = collection.Aggregate(new AggregateArgs
        {
            Pipeline = new[] { matchRequestFromDate, matchRequestToDate},              
            AllowDiskUse = true,
            // Setting the OutputMode to Cursor allows us to return Mongo Doc Size > 16 MB - in the case when a large date  
            // range is used or a large number of cars were modified in a short period of time
            OutputMode = AggregateOutputMode.Cursor
        }).Select(r => r.Values.Select(c => c.AsObjectId.ToString()).First());

        var returnData = collection.AsQueryable().Where(c => cars.Contains(c.Id)).Select(c => c);

        return returnData;
    }

public IEnumerable GetCarsModifiedPeriod（DateTimeOffset dateFrom，DateTimeOffset dateTo）
{
var matchRequestFromDate=新的BsonDocument
{
{
“$match”，
新的B文件
{
{
//过滤掉那些最近修改过的
“LastUpdateOn.0”，新的BsonDocument{{“$gte”，dateFrom.Ticks}
}
}
}
};
var matchRequestToDate=新的BsonDocument
{
{
“$match”，
新的B文件
{
{
//过滤掉那些最近修改过的
“LastUpdateOn.0”，新的BsonDocument{{“$lte”，dateTo.Ticks}
}
}
}
};
var cars=collection.Aggregate（新的AggregateArgs
{
管道=新[]{matchRequestFromDate，matchRequestToDate}，
AllowDiskUse=true，
//将OutputMode设置为Cursor允许我们返回Mongo Doc Size>16MB的值-在日期较大的情况下
//在短时间内使用了射程或改装了大量汽车
OutputMode=AggregateOutputMode.Cursor
}).Select（r=>r.Values.Select（c=>c.AsObjectId.ToString（））.First（））；
var returnData=collection.AsQueryable（）。其中（c=>cars.Contains（c.Id））。选择（c=>c）；
返回数据；
}

在指定的两个时段内，在returnData上设置了一个断点，我得到了25辆车的计数，这正是我所期望的

这就是我试图为2.7.0版本的驱动程序重新编写的方式：

    public IEnumerable<Car> GetCarsModifiedInPeriod(DateTimeOffset dateFrom, DateTimeOffset dateTo)
    {
        var matchRequestFromDate = new BsonDocument
        {
            {
                "$match",
                new BsonDocument
                {
                    {
                        // Filter out those too recently modified
                       "LastUpdatedOn.0", new BsonDocument {{"$gte", dateFrom.Ticks}}
                    }
                }
            }
        };
        var matchRequestToDate = new BsonDocument
        {
            {
                "$match",
                new BsonDocument
                {
                    {
                        // Filter out those too recently modified
                        "LastUpdatedOn.0", new BsonDocument {{"$lte", dateTo.Ticks}}
                    }
                }
            }
        };

        var pipeline = new[] {matchRequestFromDate, matchRequestToDate};
        //var mongoPipeline = new AggregateArgs { Pipeline = pipeline, AllowDiskUse = true, OutputMode = AggregateOutputMode.Cursor };

        var aggregate = collection.Aggregate(); //.Match(mongoPipeline);

        aggregate.Options.AllowDiskUse = true;
        aggregate.Options.UseCursor = true;

        foreach (var pipe in pipeline)
        {
            aggregate.AppendStage<BsonDocument>(pipe);
        }

        var returnData = aggregate.ToList();

        return returnData;  
    }

public IEnumerable GetCarsModifiedPeriod（DateTimeOffset dateFrom，DateTimeOffset dateTo）
{
var matchRequestFromDate=新的BsonDocument
{
{
“$match”，
新的B文件
{
{
//过滤掉那些最近修改过的
“LastUpdateOn.0”，新的BsonDocument{{“$gte”，dateFrom.Ticks}
}
}
}
};
var matchRequestToDate=新的BsonDocument
{
{
“$match”，
新的B文件
{
{
//过滤掉那些最近修改过的
“LastUpdateOn.0”，新的BsonDocument{{“$lte”，dateTo.Ticks}
}
}
}
};
var pipeline=new[]{matchRequestFromDate，matchRequestToDate}；
//var mongoPipeline=newaggregateargs{Pipeline=Pipeline，AllowDiskUse=true，OutputMode=AggregateOutputMode.Cursor}；
var aggregate=collection.aggregate（）；/.Match（mongoPipeline）；
aggregate.Options.AllowDiskUse=true；
aggregate.Options.UseCursor=true；
foreach（管道中的var管道）
{
集料台（管）；
}
var returnData=aggregate.ToList（）；
返回数据；
}

---

如果我用这种方法在returnData中设置一个断点，我会得到大约10K辆车的计数，因此看起来我没有正确地应用相同的匹配项

您在

BsonDocument

s中做所有事情有什么原因吗？有一些方法可以让你的生活更轻松，比如这样的方法

collection.Aggregate(new AggregateOptions() { AllowDiskUse = true, UseCursor = true })
.Match(Builders<BsonDocument>.Filter.Gte("LastUpdatedOn.0", dateFrom.Ticks) & Builders<BsonDocument>.Filter.Lte("LastUpdatedOn.0", dateFrom.Ticks))
.ToListAsync()

collection.Aggregate（新的AggregateOptions（）{AllowDiskUse=true，UseCursor=true}）
.Match（Builders.Filter.Gte（“LastUpdatedOn.0”，dateFrom.Ticks）和Builders.Filter.Lte（“LastUpdatedOn.0”，dateFrom.Ticks））
.ToListAsync（）

通过为集合和构建器使用正确的类，您还可以对过滤进行更多的整理

---

看看这个查询，我不确定您是否需要使用聚合，除非您所做的不仅仅是匹配。它可能只是一个查找。

我猜AppendStage不会改变对象，而是返回一个新对象，因此您需要类似于

aggregate=aggregate.AppendStage（pipe）的东西@Chris-获取该代码的生成错误-无法将类型“MongoDB.Driver.IAggregateFluent”隐式转换为“MongoDB.Driver.IAggregateFluent”。存在显式转换（您是否缺少转换？代码段Lte和dateTo.Ticks中是否存在&部分？我还收到该代码的生成错误-无法隐式将类型“MongoDB.Driver.iaggegatefluent”转换为“MongoDB.Driver.iaggegatefluent”。存在显式转换（您是否缺少转换？）我把BsonDocument换成了Car，把第二个Gte换成了Lte，它似乎起了作用