C# 将Azure DocumentDB中的MongoDB与.NET驱动程序一起使用会引发MongoCommandException

我正在使用Azure DocumentDB操作MongoDB集合

根据我的Azure标准计划，我有1000 RU/s的限制

当我尝试对MongoDB集合中的一些数据进行筛选和排序时，就会遇到这个问题

下面是我使用.NET MongoDB驱动程序2.4.2.0编写的C#代码：

    // GET api/movies
    [HttpGet]
    public async Task<IActionResult> Get([RequiredFromQuery] int page, [FromQuery] int limit,
        [FromQuery] string quality, [FromQuery] int minimumRating, [FromQuery] string queryTerm, [FromQuery] string genre, [FromQuery] string sortBy, [FromQuery] string orderBy)
    {
        var nbMoviesPerPage = 20;
        if (limit >= 20 && limit <= 50)
        {
            nbMoviesPerPage = limit;
        }

        var currentPage = 1;
        if (page >= 1)
        {
            currentPage = page;
        }

        var movies = _mongoDbService.GetCollection(Constants.MoviesCollectionName);
        var filter = Builders<MovieBson>.Filter.Empty;
        var sort = Builders<MovieBson>.Sort.Descending(movie => movie.DateUploadedUnix);

        if (!string.IsNullOrWhiteSpace(quality) &&
            (quality == "720p" || quality == "1080p" || quality.ToLower() == "3d"))
        {
            filter = filter & Builders<MovieBson>.Filter.Eq("torrents.quality", quality);
        }

        if (minimumRating > 0 && minimumRating < 10)
        {
            filter = filter & Builders<MovieBson>.Filter.Gt("rating", minimumRating);
        }

        if (!string.IsNullOrWhiteSpace(queryTerm))
        {
            filter = filter &
                     (Builders<MovieBson>.Filter.Regex("imdb_code", new BsonRegularExpression("/^" + queryTerm + "$/i")) |
                      Builders<MovieBson>.Filter.Regex("title", new BsonRegularExpression("/^" + queryTerm + "$/i")) |
                      Builders<MovieBson>.Filter.Regex("cast.name", new BsonRegularExpression("/^" + queryTerm + "$/i")) |
                      Builders<MovieBson>.Filter.Regex("cast.imdb_code", new BsonRegularExpression("/^" + queryTerm + "$/i")));
        }

        if (!string.IsNullOrWhiteSpace(genre))
        {
            filter = filter & Builders<MovieBson>.Filter.In("genres", new List<string>
            {
                genre
            });
        }

        if (!string.IsNullOrWhiteSpace(sortBy))
        {
            switch (sortBy)
            {
                case "title":
                    sort = Builders<MovieBson>.Sort.Ascending(movie => movie.Title);
                    break;
                case "year":
                    sort = Builders<MovieBson>.Sort.Descending(movie => movie.Year);
                    break;
                case "rating":
                    sort = Builders<MovieBson>.Sort.Descending(movie => movie.Rating);
                    break;
                case "peers":
                    sort =
                        Builders<MovieBson>.Sort.Descending(movie => movie.Torrents.Select(torrent => torrent.Peers));
                    break;
                case "seeds":
                    sort =
                        Builders<MovieBson>.Sort.Descending(movie => movie.Torrents.Select(torrent => torrent.Seeds));
                    break;
                case "download_count":
                    sort = Builders<MovieBson>.Sort.Descending(movie => movie.DownloadCount);
                    break;
                case "like_count":
                    sort = Builders<MovieBson>.Sort.Descending(movie => movie.LikeCount);
                    break;
                case "date_added":
                    sort = Builders<MovieBson>.Sort.Descending(movie => movie.DateUploadedUnix);
                    break;
                default:
                    sort = Builders<MovieBson>.Sort.Descending(movie => movie.DateUploadedUnix);
                    break;
            }
        }

        var filteredMovies = movies.Find(filter);
        var totalTask = filteredMovies.CountAsync();
        var moviesTask = filteredMovies.Skip((currentPage - 1) * nbMoviesPerPage).Limit(nbMoviesPerPage).Sort(sort).ToListAsync();
        await Task.WhenAll(totalTask, moviesTask);

        if (!string.IsNullOrWhiteSpace(orderBy))
        {
            switch (orderBy)
            {
                case "desc":
                    moviesTask.Result.Reverse();
                    break;
            }
        }

        return
            Json(new MovieResponse
            {
                TotalMovies = totalTask.Result,
                Movies = JsonConvert.DeserializeObject<IEnumerable<MovieJson>>(moviesTask.Result.ToJson())
            });
    }

//获取api/电影
[HttpGet]
公共异步任务获取（[RequiredFromQuery]int页，[FromQuery]int限制，
[FromQuery]字符串质量，[FromQuery]int minimumRating，[FromQuery]字符串查询项，[FromQuery]字符串类型，[FromQuery]字符串排序依据，[FromQuery]字符串排序依据）
{
var nbMoviesPerPage=20；
如果（限制>=20&&limit=1）
{
当前页面=第页；
}
var movies=\u mongoDbService.GetCollection（Constants.moviescolectionname）；
var filter=Builders.filter.Empty；
var sort=Builders.sort.Descending（movie=>movie.DateUploadedUnix）；
if（！string.IsNullOrWhiteSpace（质量）&&
（quality==“720p”| | quality==“1080p”| | quality.ToLower（）==“3d”））
{
filter=filter&Builders.filter.Eq（“torrents.quality”，quality）；
}
如果（最小额定值>0和最小额定值<10）
{
过滤器=过滤器&Builders.filter.Gt（“额定值”，最小额定值）；
}
如果（！string.IsNullOrWhiteSpace（queryTerm））
{
过滤器=过滤器&
（Builders.Filter.Regex（“imdb_代码”，新的BsonRegularExpression（“/^”+queryTerm+“$/i”））|
Builders.Filter.Regex（“title”，新的BsonRegularExpression（“/^”+queryTerm+“$/i”））|
Builders.Filter.Regex（“cast.name”，新的BsonRegularExpression（“/^”+queryTerm+“$/i”））|
Builders.Filter.Regex（“cast.imdb_code”，新的BsonRegularExpression（“/^”+queryTerm+“$/i”）；
}
如果（！string.IsNullOrWhiteSpace（类型））
{
filter=filter&Builders.filter.In（“流派”，新列表）
{
体裁
});
}
如果（！string.IsNullOrWhiteSpace（sortBy））
{
开关（sortBy）
{
案例“标题”：
sort=Builders.sort.升序（movie=>movie.Title）；
打破
案件“年份”：
sort=Builders.sort.Descending（movie=>movie.Year）；
打破
案例“评级”：
sort=Builders.sort.Descending（movie=>movie.Rating）；
打破
案例“同行”：
分类=
Builders.Sort.Descending（movie=>movie.Torrents.Select（torrent=>torrent.Peers））；
打破
案例“种子”：
分类=
Builders.Sort.Descending（movie=>movie.Torrents.Select（torrent=>torrent.Seeds））；
打破
案例“下载计数”：
sort=Builders.sort.Descending（movie=>movie.DownloadCount）；
打破
案例“类似计数”：
sort=Builders.sort.Descending（movie=>movie.LikeCount）；
打破
案例“添加日期”：
sort=Builders.sort.Descending（movie=>movie.DateUploadedUnix）；
打破
违约：
sort=Builders.sort.Descending（movie=>movie.DateUploadedUnix）；
打破
}
}
var filteredMovies=movies.Find（过滤器）；
var totalTask=filteredMovies.CountAsync（）；
var moviesTask=filteredMovies.Skip（（当前页-1）*nbMoviesPerPage.Limit（nbMoviesPerPage.Sort（Sort）.toListSync（）；
等待任务。WhenAll（总任务、电影任务）；
如果（！string.IsNullOrWhiteSpace（orderBy））
{
交换机（订购方）
{
案例“desc”：
moviesTask.Result.Reverse（）；
打破
}
}
返回
Json（新电影响应）
{
TotalMovies=totalTask.Result，
Movies=JsonConvert.DeserializeObject（moviesTask.Result.ToJson（））
});
}

当我使用routeapi/movies？page=1&queryTerm=TitaniC调用控制器时，MongoDB命令输出为：

{查找（{“$或”：[{“imdb_代码”：/^TitaniC$/i}，{“标题”：/^TitaniC$/i}，{“cast.name”：/^TitaniC$/i}，{“cast.imdb_代码”：/^TitaniC$/i}）。排序（{“上载日期”\uUnix:-1}）。跳过（0）。限制（20）}

这看起来很好，可以检索适当的文档

但很随机地，我从Azure收到一个429 HTTP错误，告诉我：

'命令查找失败：消息：{“错误”：[“请求速率很大”]}

---

但是，我只调用了一次API，没有其他请求…

为什么会发生这种情况；-当MongoDB无法使用索引获取查询的排序顺序时，它会在内存中对结果进行排序。如果排序操作消耗超过32兆字节，则抛出上述错误。解决此问题的一种可能方法是使用allowDiskUse选项启用聚合管道阶段将数据写入临时文件。结帐

---

您是否查看了返回标题以了解查询的成本？如果你在1秒内燃烧超过1000RU，你会被节流。但除非您查看您的查询/查询的RU成本，否则真的没有办法知道。我将查看RU，但我刚刚查看了Azure portal中的限制请求图表，没有显示如下所示：

var data = await movies.Aggregate(new AggregateOptions
        {
            AllowDiskUse = true,
        })
            .Match({})//Insert your query here
            .Skip(2)
            .Sort({ "_id", -1 } )//Insert your sort options here
            .Limit(20)
            .ToListAsync();