C# Cosmos DB，如果在使用SkipToken进行查询时更新某些项，会发生什么情况？

如果我用SkipToken从CosmosDB查询项目

类似于伪代码：

do{
   var page = Query();
   foreach(var item in page)
   {
      Update(item);
   }
}while(HasNextPage());

我得到的页面可能不完整，这意味着我将错过一些项目

但如果我在更新后等待片刻 比如：

，错误将不会发生，我将获得完整的页面和所有我需要的

---

那么这样一个过程发生了什么呢？

您不必在代码中等待，这个功能由CosmosDB内部处理。例如，我在下面的C中添加了处理服务器端分页的代码，以了解其工作原理：

您能添加查询详细信息吗？使用sql，我可以尝试在我的身边重现问题。

do{
   var page = Query();
   foreach(var item in page)
   {
      Update(item);
   }

   // difference here:
   WaitAMoment();
}while(HasNextPage());

private static async Task QueryPartitionedContainerInParallelAsync(Container container)
        {
            List<Family> familiesSerial = new List<Family>();
            string queryText = "SELECT * FROM Families";

            // 0 maximum parallel tasks, effectively serial execution
            QueryRequestOptions options = new QueryRequestOptions() { MaxBufferedItemCount = 100 };
            options.MaxConcurrency = 0;
            using (FeedIterator<Family> query = container.GetItemQueryIterator<Family>(
                queryText,
                requestOptions: options))
            {
                while (query.HasMoreResults)
                {
                    foreach (Family family in await query.ReadNextAsync())
                    {
                        familiesSerial.Add(family);
                    }
                }
            }

            Assert("Parallel Query expected two families", familiesSerial.ToList().Count == 2);

            // 1 maximum parallel tasks, 1 dedicated asynchronous task to continuously make REST calls
            List<Family> familiesParallel1 = new List<Family>();

            options.MaxConcurrency = 1;
            using (FeedIterator<Family> query = container.GetItemQueryIterator<Family>(
                queryText,
                requestOptions: options))
            {
                while (query.HasMoreResults)
                {
                    foreach (Family family in await query.ReadNextAsync())
                    {
                        familiesParallel1.Add(family);
                    }
                }
            }

            Assert("Parallel Query expected two families", familiesParallel1.ToList().Count == 2);
            AssertSequenceEqual("Parallel query returns result out of order compared to serial execution", familiesSerial, familiesParallel1);


            // 10 maximum parallel tasks, a maximum of 10 dedicated asynchronous tasks to continuously make REST calls
            List<Family> familiesParallel10 = new List<Family>();

            options.MaxConcurrency = 10;
            using (FeedIterator<Family> query = container.GetItemQueryIterator<Family>(
                queryText,
                requestOptions: options))
            {
                while (query.HasMoreResults)
                {
                    foreach (Family family in await query.ReadNextAsync())
                    {
                        familiesParallel10.Add(family);
                    }
                }
            }

            Assert("Parallel Query expected two families", familiesParallel10.ToList().Count == 2);
            AssertSequenceEqual("Parallel query returns result out of order compared to serial execution", familiesSerial, familiesParallel10);
        }