C# MongoDB 驅動程序只返回 100 個結果

Question

我正在寫一個郵寄標簽，需要為每個文件打印一個標簽。

我在 Collection 上有 829 個文檔，但是當我檢索它們時，我只得到 100 個文檔。

我有這個 LINQ 代碼：

IMongoCollection Pessoa;
Pessoa = database.GetCollection<Pessoa>(collectionName);

return Pessoa.AsQueryable().ToList();

如何檢索所有文件？

Answer 1

我在 Collection 上有 829 個文檔，但是當我檢索它們時，我只得到 100 個文檔。

我可以在我這邊重現這個問題，使用 IMongoCollection collection.AsQueryable()上的 AsQueryable 擴展方法來查找集合中的文檔，即使我在 Azure 門戶上將每頁設置更改為無限，它也總是返回 100 個文檔。

環境：

測試代碼：

計算查詢資源管理器中的文檔：

要查詢集合中的所有文檔，如您在評論中提到的，您可以嘗試使用空過濾器調用Find 方法。

Answer 2

您可能受到默認光標 BatchSize 的限制。 您可以修改此行為，將AggregateOptions對象傳遞給AsQueryable擴展並將BatchSize屬性設置為足夠大的值。

public static IMongoQueryable<TDocument> AsQueryable<TDocument>(this IMongoCollection<TDocument> collection, AggregateOptions aggregateOptions = null)

Answer 3

我發現這個問題很有用，所以我寫了一個方便的IEnumerator ：

        private sealed class MongoCollectionEnumerator : IEnumerator<T> {
            private IMongoCollection<T> _collection;
            private IAsyncCursor<T> _cursor; // outer enumerator
            private IEnumerator<T> _currentBatchEnumerator; // inner enumerator

            public MongoCollectionEnumerator(IMongoCollection<T> collection) {
                _collection = collection;

                InternalInit();
            }

            #region interface implementation
            T IEnumerator<T>.Current {
                get {
                    return _currentBatchEnumerator.Current;
                }
            }

            object IEnumerator.Current {
                get {
                    return ThisAsTypedIEnumerator.Current;
                }
            }

            bool IEnumerator.MoveNext() {
                if (_currentBatchEnumerator != null) {
                    if (_currentBatchEnumerator.MoveNext()) {
                        return true;
                    }
                }

                // inner not initialized or already at end
                if (_cursor.MoveNext()) {
                    // advance the outer and defer back to the inner by recursing
                    _currentBatchEnumerator = _cursor.Current.GetEnumerator();
                    return ThisAsIEnumerator.MoveNext();
                }
                else { // outer cannot advance, this is the end
                    return false;
                }
            }

            void IEnumerator.Reset() {
                InternalCleanUp();
                InternalInit();
            }
            #endregion

            #region methods private
            // helper properties to retrieve an explicit interface-casted this
            private IEnumerator ThisAsIEnumerator => this;
            private IEnumerator<T> ThisAsTypedIEnumerator => this;

            private void InternalInit() {
                var filterBuilder = new FilterDefinitionBuilder<T>();
                _cursor = _collection.Find(filterBuilder.Empty).ToCursor();
            }

            private void InternalCleanUp() {
                if (_currentBatchEnumerator != null) {
                    _currentBatchEnumerator.Reset();
                    _currentBatchEnumerator = null;
                }

                if (_cursor != null) {
                    _cursor.Dispose();
                    _cursor = null;
                }
            }
            #endregion

            #region IDisposable implementation
            private bool disposedValue = false; // To detect redundant calls

            private void InternalDispose(bool disposing) {
                if (!disposedValue) {
                    if (disposing) {
                        InternalCleanUp();

                        _collection = null;
                    }

                    disposedValue = true;
                }
            }

            void IDisposable.Dispose() {
                InternalDispose(true);
            }
            #endregion
        }