From 4ad1d87db2418354abd30e4cbe4a24ab5adbfb9f Mon Sep 17 00:00:00 2001
From: Samuel Wanjohi <sam.wanjohi94@gmail.com>
Date: Wed, 25 Jun 2025 07:51:24 +0300
Subject: [PATCH 1/7] trying optimize TruncatedCollectionOfT and add support
 for IAsyncEnumerable

---
 .../Microsoft.AspNetCore.OData.csproj         |   3 +-
 .../Query/Container/TruncatedCollectionOfT.cs | 295 +++++++++++++-----
 2 files changed, 211 insertions(+), 87 deletions(-)

diff --git a/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.csproj b/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.csproj
index 507f2d72..7b06a384 100644
--- a/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.csproj
+++ b/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
@@ -35,6 +35,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="System.Linq.AsyncEnumerable" Version="10.0.0-preview.5.25277.114" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
index fc62d83f..ba39a7dc 100644
--- a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
+++ b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
@@ -6,8 +6,11 @@
 //------------------------------------------------------------------------------
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Microsoft.AspNetCore.OData.Query.Container;
 
@@ -15,161 +18,281 @@ namespace Microsoft.AspNetCore.OData.Query.Container;
 /// Represents a class that truncates a collection to a given page size.
 /// </summary>
 /// <typeparam name="T">The collection element type.</typeparam>
-public class TruncatedCollection<T> : List<T>, ITruncatedCollection, IEnumerable<T>, ICountOptionCollection
+public class TruncatedCollection<T> : IReadOnlyList<T>, ITruncatedCollection, ICountOptionCollection, IAsyncEnumerable<T>
 {
-    // The default capacity of the list.
-    // https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/List.cs#L23
-    private const int DefaultCapacity = 4;
     private const int MinPageSize = 1;
+    private const int DefaultCapacity = 4;
 
-    private bool _isTruncated;
-    private int _pageSize;
-    private long? _totalCount;
+    private readonly List<T> _items;
+    private readonly IAsyncEnumerable<T> _asyncSource;
+    private readonly bool _isTruncated;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="TruncatedCollection{T}"/> class.
+    /// Private constructor used by static Create methods and public constructors.
     /// </summary>
+    /// <param name="items">The list of items in the collection.</param>
+    /// <param name="pageSize">The maximum number of items per page.</param>
+    /// <param name="totalCount">The total number of items in the source collection, if known.</param>
+    /// <param name="isTruncated">Indicates whether the collection is truncated.</param>
+    private TruncatedCollection(List<T> items, int pageSize, long? totalCount, bool isTruncated)
+    {
+        _items = items;
+        _isTruncated = isTruncated;
+        PageSize = pageSize;
+        TotalCount = totalCount;
+    }
+
+    /// <summary>
+    /// Private constructor used by static Create methods and public constructors.
+    /// </summary>
+    /// <param name="asyncSource">The asynchronous source of items (pageSize + 1) in the collection.</param>
+    /// <param name="pageSize">The maximum number of items per page.</param>
+    /// <param name="totalCount">The total number of items in the source collection, if known.</param>
+    /// <param name="isTruncated">Indicates whether the collection is truncated.</param>
+    private TruncatedCollection(IAsyncEnumerable<T> asyncSource, int pageSize, long? totalCount, bool isTruncated)
+    {
+        _asyncSource = asyncSource;
+        _isTruncated = isTruncated;
+        PageSize = pageSize;
+        TotalCount = totalCount;
+    }
+
+    #region Constructors for Backward Compatibility
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TruncatedCollection{T}"/> class.
     /// <param name="source">The collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
     public TruncatedCollection(IEnumerable<T> source, int pageSize)
-        : base(checked(pageSize + 1))
-    {
-        var items = source.Take(Capacity);
-        AddRange(items);
-        Initialize(pageSize);
-    }
+        : this(CreateInternal(source, pageSize, totalCount: null)) { }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="TruncatedCollection{T}"/> class.
     /// </summary>
     /// <param name="source">The queryable collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
-    // NOTE: The queryable version calls Queryable.Take which actually gets translated to the backend query where as 
-    // the enumerable version just enumerates and is inefficient.
-    public TruncatedCollection(IQueryable<T> source, int pageSize) : this(source, pageSize, false)
-    {
-    }
+    /// <param name="totalCount">The total count.</param>
+    public TruncatedCollection(IEnumerable<T> source, int pageSize, long? totalCount)
+        : this(CreateInternal(source, pageSize, totalCount)) { }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="TruncatedCollection{T}"/> class.
     /// </summary>
     /// <param name="source">The queryable collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
-    /// <param name="parameterize">Flag indicating whether constants should be parameterized</param>
-    // NOTE: The queryable version calls Queryable.Take which actually gets translated to the backend query where as 
-    // the enumerable version just enumerates and is inefficient.
-    public TruncatedCollection(IQueryable<T> source, int pageSize, bool parameterize)
-        : base(checked(pageSize + 1))
-    {
-        var items = Take(source, pageSize, parameterize);
-        AddRange(items);
-        Initialize(pageSize);
-    }
+    public TruncatedCollection(IQueryable<T> source, int pageSize)
+        : this(CreateInternal(source, pageSize, false)) { }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="TruncatedCollection{T}"/> class.
     /// </summary>
     /// <param name="source">The queryable collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
-    /// <param name="totalCount">The total count.</param>
-    public TruncatedCollection(IEnumerable<T> source, int pageSize, long? totalCount)
-        : base(pageSize > 0
-            ? checked(pageSize + 1)
-            : (totalCount > 0 ? (totalCount < int.MaxValue ? (int)totalCount : int.MaxValue) : DefaultCapacity))
+    /// <param name="parameterize">Flag indicating whether constants should be parameterized</param>
+    public TruncatedCollection(IQueryable<T> source, int pageSize, bool parameterize)
+        : this(CreateInternal(source, pageSize, parameterize)) { }
+
+    /// <summary>
+    /// Wrapper used internally by the backward-compatible constructors.
+    /// </summary>
+    /// <param name="other">An instance of <see cref="TruncatedCollection{T}"/>.</param>
+    private TruncatedCollection(TruncatedCollection<T> other)
+        : this(other._items, other.PageSize, other.TotalCount, other._isTruncated)
     {
-        if (pageSize > 0)
-        {
-            AddRange(source.Take(Capacity));
-        }
-        else
-        {
-            AddRange(source);
-        }
+    }
 
-        if (pageSize > 0)
-        {
-            Initialize(pageSize);
-        }
+    #endregion
+
+    #region Static Create Methods
 
-        _totalCount = totalCount;
+    /// <summary>
+    /// Create a truncated collection from an <see cref="IEnumerable{T}"/>.
+    /// </summary>
+    /// <param name="source">The collection to be truncated.</param>
+    /// <param name="pageSize">The page size.</param>
+    /// <param name="totalCount">The total count. Default is null.</param>
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
+    public static TruncatedCollection<T> Create(IEnumerable<T> source, int pageSize, long? totalCount = null)
+    {
+        return CreateInternal(source, pageSize, totalCount);
     }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="TruncatedCollection{T}"/> class.
+    /// Create a truncated collection from an <see cref="IQueryable{T}"/>.
     /// </summary>
-    /// <param name="source">The queryable collection to be truncated.</param>
+    /// <param name="source">The collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
-    /// <param name="totalCount">The total count.</param>
-    // NOTE: The queryable version calls Queryable.Take which actually gets translated to the backend query where as 
-    // the enumerable version just enumerates and is inefficient.
+    /// <param name="totalCount">The total count. Default is null.</param>
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
     [Obsolete("should not be used, will be marked internal in the next major version")]
-    public TruncatedCollection(IQueryable<T> source, int pageSize, long? totalCount) : this(source, pageSize,
-        totalCount, false)
+    public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize, long? totalCount = null)
     {
+        return CreateInternal(source, pageSize, false, totalCount);
     }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="TruncatedCollection{T}"/> class.
+    /// Create a truncated collection from an <see cref="IQueryable{T}"/>.
     /// </summary>
-    /// <param name="source">The queryable collection to be truncated.</param>
+    /// <param name="source">The collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
-    /// <param name="totalCount">The total count.</param>
     /// <param name="parameterize">Flag indicating whether constants should be parameterized</param>
-    // NOTE: The queryable version calls Queryable.Take which actually gets translated to the backend query where as 
-    // the enumerable version just enumerates and is inefficient.
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
+    public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize, bool parameterize)
+    {
+        return CreateInternal(source, pageSize, parameterize);
+    }
+
+    /// <summary>
+    /// Create a truncated collection from an <see cref="IQueryable{T}"/>.
+    /// </summary>
+    /// <param name="source">The collection to be truncated.</param>
+    /// <param name="pageSize">The page size.</param>
+    /// <param name="totalCount">The total count. Default is null.</param>
+    /// <param name="parameterize">Flag indicating whether constants should be parameterized</param>
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
     [Obsolete("should not be used, will be marked internal in the next major version")]
-    public TruncatedCollection(IQueryable<T> source, int pageSize, long? totalCount, bool parameterize)
-        : base(pageSize > 0 ? Take(source, pageSize, parameterize) : source)
+    public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize, long? totalCount, bool parameterize)
     {
-        if (pageSize > 0)
-        {
-            Initialize(pageSize);
-        }
+        return CreateInternal(source, pageSize, parameterize, totalCount);
+    }
 
-        _totalCount = totalCount;
+    /// <summary>
+    /// Create an async truncated collection from an <see cref="IAsyncEnumerable{T}"/>.
+    /// </summary>
+    /// <param name="source">The AsyncEnumerable to be truncated.</param>
+    /// <param name="pageSize">The page size.</param>
+    /// <param name="totalCount">The total count. Default is null.</param>
+    /// <param name="cancellationToken">Cancellation token for async operations. Default is <see cref="default"/></param>
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"/></returns>
+    public static async Task<TruncatedCollection<T>> CreateAsync(IAsyncEnumerable<T> source, int pageSize, long? totalCount = null, CancellationToken cancellationToken = default)
+    {
+        return await CreateInternalAsync(source, pageSize, totalCount, cancellationToken).ConfigureAwait(false);
     }
 
-    private void Initialize(int pageSize)
+    #endregion
+
+    #region Core Internal (Sync/Async)
+
+    private static TruncatedCollection<T> CreateInternal(IEnumerable<T> source, int pageSize, long? totalCount)
     {
-        if (pageSize < MinPageSize)
+        ValidateArgs(source, pageSize);
+
+        int capacity = pageSize > 0 ? checked(pageSize + 1) : (totalCount > 0 ? (totalCount < int.MaxValue ? (int)totalCount : int.MaxValue) : DefaultCapacity);
+        var items = source.Take(capacity);
+
+        var smallPossibleCount = capacity < items.Count() ? items.Count() : capacity;
+        var buffer = new List<T>(smallPossibleCount);
+        buffer.AddRange(items);
+
+        bool isTruncated = buffer.Count > pageSize;
+        if (isTruncated)
         {
-            throw Error.ArgumentMustBeGreaterThanOrEqualTo("pageSize", pageSize, MinPageSize);
+            buffer.RemoveAt(buffer.Count - 1);
         }
 
-        _pageSize = pageSize;
+        return new TruncatedCollection<T>(buffer, pageSize, totalCount, isTruncated: isTruncated);
+    }
+
+    private static TruncatedCollection<T> CreateInternal(IQueryable<T> source, int pageSize, bool parameterize = false, long? totalCount = null)
+    {
+        ValidateArgs(source, pageSize);
 
-        if (Count > pageSize)
+        int capacity = pageSize > 0 ? pageSize : (totalCount > 0 ? (totalCount < int.MaxValue ? (int)totalCount : int.MaxValue) : DefaultCapacity);
+        var items = Take(source, capacity, parameterize);
+
+        int count = 0;
+        var buffer = new List<T>(pageSize);
+        using IEnumerator<T> enumerator = items.GetEnumerator();
+        while (count < pageSize && enumerator.MoveNext())
         {
-            _isTruncated = true;
-            RemoveAt(Count - 1);
+            buffer.Add(enumerator.Current);
+            count++;
         }
+
+        return new TruncatedCollection<T>(buffer, pageSize, totalCount, isTruncated: enumerator.MoveNext());
     }
 
-    private static IQueryable<T> Take(IQueryable<T> source, int pageSize, bool parameterize)
+    private static async Task<TruncatedCollection<T>> CreateInternalAsync(IAsyncEnumerable<T> source, int pageSize, long? totalCount, CancellationToken cancellationToken)
     {
-        if (source == null)
+        ValidateArgs(source, pageSize);
+
+        int capacity = pageSize > 0 ? pageSize : (totalCount > 0 ? (totalCount < int.MaxValue ? (int)totalCount : int.MaxValue) : DefaultCapacity);
+        var buffer = new List<T>(capacity);
+
+        bool isTruncated = false;
+        int count = 0;
+        await foreach (var item in source.Take(checked(capacity + 1)).WithCancellation(cancellationToken).ConfigureAwait(false))
         {
-            throw Error.ArgumentNull("source");
+            if (count < pageSize)
+            {
+                buffer.Add(item);
+                count++;
+            }
+            else
+            {
+                isTruncated = true;
+                break;
+            }
         }
 
-        return ExpressionHelpers.Take(source, checked(pageSize + 1), typeof(T), parameterize) as IQueryable<T>;
+        // Create a new async enumerable from the buffer
+        IAsyncEnumerable<T> truncatedSource = GetAsyncEnumerable(buffer);
+
+        return new TruncatedCollection<T>(truncatedSource, pageSize, totalCount, isTruncated);
+
+        static async IAsyncEnumerable<T> GetAsyncEnumerable(IEnumerable<T> items)
+        {
+            foreach (var item in items)
+                yield return item;
+
+            await Task.CompletedTask;
+        }
     }
 
-    /// <inheritdoc />
-    public int PageSize
+    private static IQueryable<T> Take(IQueryable<T> source, int pageSize, bool parameterize)
     {
-        get { return _pageSize; }
+        // This uses existing ExpressionHelpers from OData to apply Take(pageSize + 1)
+        return (IQueryable<T>)ExpressionHelpers.Take(source, checked(pageSize + 1), typeof(T), parameterize);
     }
 
-    /// <inheritdoc />
-    public bool IsTruncated
+    private static void ValidateArgs(object source, int pageSize)
     {
-        get { return _isTruncated; }
+        ArgumentNullException.ThrowIfNull(source);
+
+        if (pageSize < MinPageSize)
+            throw new ArgumentOutOfRangeException(nameof(pageSize), $"Page size must be >= {MinPageSize}.");
     }
 
-    /// <inheritdoc />
-    public long? TotalCount
+    #endregion
+
+    /// <inheritdoc/>
+    public int PageSize { get; }
+    /// <inheritdoc/>
+    public long? TotalCount { get; }
+    /// <inheritdoc/>
+    public bool IsTruncated => _isTruncated;
+
+    /// <inheritdoc/>
+    public int Count => _items != null ? _items.Count : 0;
+
+    public T this[int index] => _items[index];
+    //public List<T> AsList() => new List<T>(_items);
+
+    /// <inheritdoc/>
+    public IEnumerator<T> GetEnumerator() => _items.GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => _items.GetEnumerator();
+
+    /// <inheritdoc/>
+    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
     {
-        get { return _totalCount; }
+        return GetPagedAsyncEnumerator(cancellationToken);
+
+        async IAsyncEnumerator<T> GetPagedAsyncEnumerator(CancellationToken ct)
+        {
+            await foreach (var item in _asyncSource.WithCancellation(ct).ConfigureAwait(false))
+            {
+                yield return item;
+            }
+        }
     }
 }

From a3b8eb7123c923264ff864c390a623b3c452bc25 Mon Sep 17 00:00:00 2001
From: Samuel Wanjohi <sam.wanjohi94@gmail.com>
Date: Wed, 25 Jun 2025 20:08:37 +0300
Subject: [PATCH 2/7] refactor

---
 .../Query/Container/TruncatedCollectionOfT.cs | 35 +++++++++++++++----
 1 file changed, 29 insertions(+), 6 deletions(-)

diff --git a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
index ba39a7dc..b520ec9f 100644
--- a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
+++ b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
@@ -25,6 +25,7 @@ public class TruncatedCollection<T> : IReadOnlyList<T>, ITruncatedCollection, IC
 
     private readonly List<T> _items;
     private readonly IAsyncEnumerable<T> _asyncSource;
+
     private readonly bool _isTruncated;
 
     /// <summary>
@@ -61,6 +62,7 @@ private TruncatedCollection(IAsyncEnumerable<T> asyncSource, int pageSize, long?
 
     /// <summary>
     /// Initializes a new instance of the <see cref="TruncatedCollection{T}"/> class.
+    /// </summary>
     /// <param name="source">The collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
     public TruncatedCollection(IEnumerable<T> source, int pageSize)
@@ -110,9 +112,20 @@ private TruncatedCollection(TruncatedCollection<T> other)
     /// </summary>
     /// <param name="source">The collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
-    /// <param name="totalCount">The total count. Default is null.</param>
-    /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
-    public static TruncatedCollection<T> Create(IEnumerable<T> source, int pageSize, long? totalCount = null)
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"></see></returns>
+    public static TruncatedCollection<T> Create(IEnumerable<T> source, int pageSize)
+    {
+        return CreateInternal(source, pageSize, null);
+    }
+
+    /// <summary>
+    /// Create a truncated collection from an <see cref="IEnumerable{T}"/>.
+    /// </summary>
+    /// <param name="source">The collection to be truncated.</param>
+    /// <param name="pageSize">The page size.</param>
+    /// <param name="totalCount">The total count.</param>
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"></see></returns>
+    public static TruncatedCollection<T> Create(IEnumerable<T> source, int pageSize, long? totalCount)
     {
         return CreateInternal(source, pageSize, totalCount);
     }
@@ -122,10 +135,21 @@ public static TruncatedCollection<T> Create(IEnumerable<T> source, int pageSize,
     /// </summary>
     /// <param name="source">The collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
-    /// <param name="totalCount">The total count. Default is null.</param>
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
+    public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize)
+    {
+        return CreateInternal(source, pageSize, false, null);
+    }
+
+    /// <summary>
+    /// Create a truncated collection from an <see cref="IQueryable{T}"/>.
+    /// </summary>
+    /// <param name="source">The collection to be truncated.</param>
+    /// <param name="pageSize">The page size.</param>
+    /// <param name="totalCount">The total count.</param>
     /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
     [Obsolete("should not be used, will be marked internal in the next major version")]
-    public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize, long? totalCount = null)
+    public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize, long? totalCount)
     {
         return CreateInternal(source, pageSize, false, totalCount);
     }
@@ -276,7 +300,6 @@ private static void ValidateArgs(object source, int pageSize)
     public int Count => _items != null ? _items.Count : 0;
 
     public T this[int index] => _items[index];
-    //public List<T> AsList() => new List<T>(_items);
 
     /// <inheritdoc/>
     public IEnumerator<T> GetEnumerator() => _items.GetEnumerator();

From 359c2f940e1b3fed88f1a5f273ccd025cea67cbc Mon Sep 17 00:00:00 2001
From: Samuel Wanjohi <sam.wanjohi94@gmail.com>
Date: Wed, 25 Jun 2025 20:37:02 +0300
Subject: [PATCH 3/7] Add some tests

---
 .../Microsoft.AspNetCore.OData.xml            | 92 ++++++++++++++++---
 .../PublicAPI.Unshipped.txt                   | 12 +++
 .../Query/Container/TruncatedCollectionOfT.cs | 51 ++++++++--
 .../Container/TruncatedCollectionOfTTest.cs   | 50 +++++++++-
 4 files changed, 180 insertions(+), 25 deletions(-)

diff --git a/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.xml b/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.xml
index 14483fa3..abbb3fe9 100644
--- a/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.xml
+++ b/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.xml
@@ -8914,6 +8914,24 @@
             </summary>
             <typeparam name="T">The collection element type.</typeparam>
         </member>
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Collections.Generic.List{`0},System.Int32,System.Nullable{System.Int64},System.Boolean)">
+            <summary>
+            Private constructor used by static Create methods and public constructors.
+            </summary>
+            <param name="items">The list of items in the collection.</param>
+            <param name="pageSize">The maximum number of items per page.</param>
+            <param name="totalCount">The total number of items in the source collection, if known.</param>
+            <param name="isTruncated">Indicates whether the collection is truncated.</param>
+        </member>
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Collections.Generic.IAsyncEnumerable{`0},System.Int32,System.Nullable{System.Int64},System.Boolean)">
+            <summary>
+            Private constructor used by static Create methods and public constructors.
+            </summary>
+            <param name="asyncSource">The asynchronous source of items (pageSize + 1) in the collection.</param>
+            <param name="pageSize">The maximum number of items per page.</param>
+            <param name="totalCount">The total number of items in the source collection, if known.</param>
+            <param name="isTruncated">Indicates whether the collection is truncated.</param>
+        </member>
         <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Int32)">
             <summary>
             Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
@@ -8921,6 +8939,14 @@
             <param name="source">The collection to be truncated.</param>
             <param name="pageSize">The page size.</param>
         </member>
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Int32,System.Nullable{System.Int64})">
+            <summary>
+            Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
+            </summary>
+            <param name="source">The queryable collection to be truncated.</param>
+            <param name="pageSize">The page size.</param>
+            <param name="totalCount">The total count.</param>
+        </member>
         <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Linq.IQueryable{`0},System.Int32)">
             <summary>
             Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
@@ -8936,39 +8962,75 @@
             <param name="pageSize">The page size.</param>
             <param name="parameterize">Flag indicating whether constants should be parameterized</param>
         </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Int32,System.Nullable{System.Int64})">
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection{`0})">
             <summary>
-            Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
+            Wrapper used internally by the backward-compatible constructors.
             </summary>
-            <param name="source">The queryable collection to be truncated.</param>
+            <param name="other">An instance of <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/>.</param>
+        </member>
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Collections.Generic.IEnumerable{`0},System.Int32)">
+            <summary>
+            Create a truncated collection from an <see cref="T:System.Collections.Generic.IEnumerable`1"/>.
+            </summary>
+            <param name="source">The collection to be truncated.</param>
             <param name="pageSize">The page size.</param>
-            <param name="totalCount">The total count.</param>
+            <returns>An instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"></see></returns>
         </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Linq.IQueryable{`0},System.Int32,System.Nullable{System.Int64})">
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Collections.Generic.IEnumerable{`0},System.Int32,System.Nullable{System.Int64})">
             <summary>
-            Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
+            Create a truncated collection from an <see cref="T:System.Collections.Generic.IEnumerable`1"/>.
             </summary>
-            <param name="source">The queryable collection to be truncated.</param>
+            <param name="source">The collection to be truncated.</param>
             <param name="pageSize">The page size.</param>
             <param name="totalCount">The total count.</param>
+            <returns>An instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"></see></returns>
         </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Linq.IQueryable{`0},System.Int32,System.Nullable{System.Int64},System.Boolean)">
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Linq.IQueryable{`0},System.Int32)">
             <summary>
-            Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
+            Create a truncated collection from an <see cref="T:System.Linq.IQueryable`1"/>.
             </summary>
-            <param name="source">The queryable collection to be truncated.</param>
+            <param name="source">The collection to be truncated.</param>
+            <param name="pageSize">The page size.</param>
+            <returns>An instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"></see></returns>
+        </member>
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Linq.IQueryable{`0},System.Int32,System.Nullable{System.Int64})">
+            <summary>
+            Create a truncated collection from an <see cref="T:System.Linq.IQueryable`1"/>.
+            </summary>
+            <param name="source">The collection to be truncated.</param>
             <param name="pageSize">The page size.</param>
             <param name="totalCount">The total count.</param>
-            <param name="parameterize">Flag indicating whether constants should be parameterized</param>
+            <returns>An instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"></see></returns>
+        </member>
+        <!-- Badly formed XML comment ignored for member "M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Linq.IQueryable{`0},System.Int32,System.Boolean)" -->
+        <!-- Badly formed XML comment ignored for member "M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Linq.IQueryable{`0},System.Int32,System.Nullable{System.Int64},System.Boolean)" -->
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.CreateAsync(System.Collections.Generic.IAsyncEnumerable{`0},System.Int32,System.Nullable{System.Int64},System.Threading.CancellationToken)">
+            <summary>
+            Create an async truncated collection from an <see cref="T:System.Collections.Generic.IAsyncEnumerable`1"/>.
+            </summary>
+            <param name="source">The AsyncEnumerable to be truncated.</param>
+            <param name="pageSize">The page size.</param>
+            <param name="totalCount">The total count. Default is null.</param>
+            <param name="cancellationToken">Cancellation token for async operations. Default is <see cref="!:default"/></param>
+            <returns>An instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/></returns>
         </member>
         <member name="P:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.PageSize">
-            <inheritdoc />
+            <inheritdoc/>
+        </member>
+        <member name="P:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.TotalCount">
+            <inheritdoc/>
         </member>
         <member name="P:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.IsTruncated">
-            <inheritdoc />
+            <inheritdoc/>
         </member>
-        <member name="P:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.TotalCount">
-            <inheritdoc />
+        <member name="P:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Count">
+            <inheritdoc/>
+        </member>
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.GetEnumerator">
+            <inheritdoc/>
+        </member>
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.GetAsyncEnumerator(System.Threading.CancellationToken)">
+            <inheritdoc/>
         </member>
         <member name="T:Microsoft.AspNetCore.OData.Query.DefaultODataQueryRequestParser">
             <summary>
diff --git a/src/Microsoft.AspNetCore.OData/PublicAPI.Unshipped.txt b/src/Microsoft.AspNetCore.OData/PublicAPI.Unshipped.txt
index 18bac592..579ce601 100644
--- a/src/Microsoft.AspNetCore.OData/PublicAPI.Unshipped.txt
+++ b/src/Microsoft.AspNetCore.OData/PublicAPI.Unshipped.txt
@@ -44,6 +44,11 @@ Microsoft.AspNetCore.OData.ODataMiniOptions.SetVersion(Microsoft.OData.ODataVers
 Microsoft.AspNetCore.OData.ODataMiniOptions.SkipToken() -> Microsoft.AspNetCore.OData.ODataMiniOptions
 Microsoft.AspNetCore.OData.ODataMiniOptions.TimeZone.get -> System.TimeZoneInfo
 Microsoft.AspNetCore.OData.ODataMiniOptions.Version.get -> Microsoft.OData.ODataVersion
+Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Count.get -> int
+Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.CountAsync() -> System.Threading.Tasks.Task<int>
+Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.GetAsyncEnumerator(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IAsyncEnumerator<T>
+Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.GetEnumerator() -> System.Collections.Generic.IEnumerator<T>
+Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.this[int index].get -> T
 Microsoft.AspNetCore.OData.Query.IODataQueryEndpointFilter
 Microsoft.AspNetCore.OData.Query.IODataQueryEndpointFilter.OnFilterExecutedAsync(object responseValue, Microsoft.AspNetCore.OData.Extensions.ODataQueryFilterInvocationContext context) -> System.Threading.Tasks.ValueTask<object>
 Microsoft.AspNetCore.OData.Query.IODataQueryEndpointFilter.OnFilterExecutingAsync(Microsoft.AspNetCore.OData.Extensions.ODataQueryFilterInvocationContext context) -> System.Threading.Tasks.ValueTask
@@ -78,6 +83,13 @@ static Microsoft.AspNetCore.OData.ODataEndpointConventionBuilderExtensions.WithO
 static Microsoft.AspNetCore.OData.ODataEndpointConventionBuilderExtensions.WithODataVersion<TBuilder>(this TBuilder builder, Microsoft.OData.ODataVersion version) -> TBuilder
 static Microsoft.AspNetCore.OData.ODataServiceCollectionExtensions.AddOData(this Microsoft.Extensions.DependencyInjection.IServiceCollection services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection
 static Microsoft.AspNetCore.OData.ODataServiceCollectionExtensions.AddOData(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Action<Microsoft.AspNetCore.OData.ODataMiniOptions> setupAction) -> Microsoft.Extensions.DependencyInjection.IServiceCollection
+static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Collections.Generic.IEnumerable<T> source, int pageSize) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
+static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Collections.Generic.IEnumerable<T> source, int pageSize, long? totalCount) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
+static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Linq.IQueryable<T> source, int pageSize) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
+static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Linq.IQueryable<T> source, int pageSize, bool parameterize) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
+static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Linq.IQueryable<T> source, int pageSize, long? totalCount) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
+static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Linq.IQueryable<T> source, int pageSize, long? totalCount, bool parameterize) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
+static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.CreateAsync(System.Collections.Generic.IAsyncEnumerable<T> source, int pageSize, long? totalCount = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>>
 static Microsoft.AspNetCore.OData.Query.ODataQueryOptions<TEntity>.BindAsync(Microsoft.AspNetCore.Http.HttpContext context, System.Reflection.ParameterInfo parameter) -> System.Threading.Tasks.ValueTask<Microsoft.AspNetCore.OData.Query.ODataQueryOptions<TEntity>>
 static Microsoft.AspNetCore.OData.Query.ODataQueryOptions<TEntity>.PopulateMetadata(System.Reflection.ParameterInfo parameter, Microsoft.AspNetCore.Builder.EndpointBuilder builder) -> void
 static readonly Microsoft.AspNetCore.OData.Query.Wrapper.SelectExpandWrapperConverter.MapperProvider -> System.Func<Microsoft.OData.Edm.IEdmModel, Microsoft.OData.Edm.IEdmStructuredType, Microsoft.AspNetCore.OData.Query.Container.IPropertyMapper>
diff --git a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
index b520ec9f..13a373ae 100644
--- a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
+++ b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
@@ -135,7 +135,7 @@ public static TruncatedCollection<T> Create(IEnumerable<T> source, int pageSize,
     /// </summary>
     /// <param name="source">The collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
-    /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"></see></returns>
     public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize)
     {
         return CreateInternal(source, pageSize, false, null);
@@ -147,8 +147,7 @@ public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize)
     /// <param name="source">The collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
     /// <param name="totalCount">The total count.</param>
-    /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
-    [Obsolete("should not be used, will be marked internal in the next major version")]
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"></see></returns>
     public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize, long? totalCount)
     {
         return CreateInternal(source, pageSize, false, totalCount);
@@ -160,7 +159,7 @@ public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize,
     /// <param name="source">The collection to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
     /// <param name="parameterize">Flag indicating whether constants should be parameterized</param>
-    /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"></see></returns>
     public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize, bool parameterize)
     {
         return CreateInternal(source, pageSize, parameterize);
@@ -173,7 +172,7 @@ public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize,
     /// <param name="pageSize">The page size.</param>
     /// <param name="totalCount">The total count. Default is null.</param>
     /// <param name="parameterize">Flag indicating whether constants should be parameterized</param>
-    /// <returns>An instance of the <see cref="TruncatedCollection{T}"</returns>
+    /// <returns>An instance of the <see cref="TruncatedCollection{T}"></see></returns>
     [Obsolete("should not be used, will be marked internal in the next major version")]
     public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize, long? totalCount, bool parameterize)
     {
@@ -186,7 +185,7 @@ public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize,
     /// <param name="source">The AsyncEnumerable to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
     /// <param name="totalCount">The total count. Default is null.</param>
-    /// <param name="cancellationToken">Cancellation token for async operations. Default is <see cref="default"/></param>
+    /// <param name="cancellationToken">Cancellation token for async operations. Default.</param>
     /// <returns>An instance of the <see cref="TruncatedCollection{T}"/></returns>
     public static async Task<TruncatedCollection<T>> CreateAsync(IAsyncEnumerable<T> source, int pageSize, long? totalCount = null, CancellationToken cancellationToken = default)
     {
@@ -284,7 +283,9 @@ private static void ValidateArgs(object source, int pageSize)
         ArgumentNullException.ThrowIfNull(source);
 
         if (pageSize < MinPageSize)
-            throw new ArgumentOutOfRangeException(nameof(pageSize), $"Page size must be >= {MinPageSize}.");
+        {
+            throw Error.ArgumentMustBeGreaterThanOrEqualTo("pageSize", pageSize, MinPageSize);
+        }
     }
 
     #endregion
@@ -297,8 +298,42 @@ private static void ValidateArgs(object source, int pageSize)
     public bool IsTruncated => _isTruncated;
 
     /// <inheritdoc/>
-    public int Count => _items != null ? _items.Count : 0;
+    public int Count
+    {
+        get
+        {
+            if (_items != null)
+            {
+                return _items.Count;
+            }
+            else if (_asyncSource != null)
+            {
+                throw new InvalidOperationException("Count cannot be accessed synchronously for an asynchronous source. Use CountAsync instead.");
+            }
+            return 0;
+        }
+    }
 
+    /// <inheritdoc/>
+    public async Task<int> CountAsync()
+    {
+        if (_items != null)
+        {
+            return await Task.FromResult(_items.Count);
+        }
+        else if (_asyncSource != null)
+        {
+            int count = 0;
+            await foreach (var _ in _asyncSource.ConfigureAwait(false))
+            {
+                count++;
+            }
+            return count;
+        }
+        return 0;
+    }
+
+    /// <inheritdoc/>
     public T this[int index] => _items[index];
 
     /// <inheritdoc/>
diff --git a/test/Microsoft.AspNetCore.OData.Tests/Query/Container/TruncatedCollectionOfTTest.cs b/test/Microsoft.AspNetCore.OData.Tests/Query/Container/TruncatedCollectionOfTTest.cs
index 2868e724..2c36c0b1 100644
--- a/test/Microsoft.AspNetCore.OData.Tests/Query/Container/TruncatedCollectionOfTTest.cs
+++ b/test/Microsoft.AspNetCore.OData.Tests/Query/Container/TruncatedCollectionOfTTest.cs
@@ -6,10 +6,11 @@
 //------------------------------------------------------------------------------
 
 using System;
-using Microsoft.AspNetCore.OData.Query.Container;
-using Microsoft.AspNetCore.OData.Tests.Commons;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.OData.Query.Container;
+using Microsoft.AspNetCore.OData.Tests.Commons;
 using Xunit;
 
 namespace Microsoft.AspNetCore.OData.Tests.Query.Container;
@@ -50,6 +51,51 @@ public void CtorTruncatedCollection_SetsProperties()
         Assert.Equal(new[] { 1, 2, 3 }, collection);
     }
 
+    [Fact]
+    public void TruncatedCollectionCreateForIEnumerable_SetsProperties()
+    {
+        // Arrange & Act
+        IEnumerable<int> source = new[] { 1, 2, 3, 5, 7 };
+        var collection = TruncatedCollection<int>.Create(source, 3, 5);
+
+        // Assert
+        Assert.Equal(3, collection.PageSize);
+        Assert.Equal(5, collection.TotalCount);
+        Assert.True(collection.IsTruncated);
+        Assert.Equal(3, collection.Count);
+        Assert.Equal(new[] { 1, 2, 3 }, collection);
+    }
+
+    [Fact]
+    public async Task TruncatedCollectionCreateForIAsyncEnumerable_SetsProperties()
+    {
+        // Arrange & Act
+        IAsyncEnumerable<int> source = new[] { 1, 2, 3, 5, 7 }.ToAsyncEnumerable();
+        var collection = await TruncatedCollection<int>.CreateAsync(source, 3, 5);
+
+        // Assert
+        Assert.Equal(3, collection.PageSize);
+        Assert.Equal(5, collection.TotalCount);
+        Assert.True(collection.IsTruncated);
+        Assert.Equal(3, await collection.CountAsync());
+        Assert.Equal(new[] { 1, 2, 3 }, await collection.ToArrayAsync());
+    }
+
+    [Fact]
+    public void TruncatedCollectionCreateForIQueryable_SetsProperties()
+    {
+        // Arrange & Act
+        IQueryable<int> source = new[] { 1, 2, 3, 5, 7 }.AsQueryable();
+        var collection = TruncatedCollection<int>.Create(source, 3, 5);
+
+        // Assert
+        Assert.Equal(3, collection.PageSize);
+        Assert.Equal(5, collection.TotalCount);
+        Assert.True(collection.IsTruncated);
+        Assert.Equal(3, collection.Count);
+        Assert.Equal(new[] { 1, 2, 3 }, collection);
+    }
+
     [Fact]
     [Obsolete]
     public void CtorTruncatedCollection_WithQueryable_SetsProperties()

From dec21262e6df3685f205d8175679dd19cd03d07b Mon Sep 17 00:00:00 2001
From: Samuel Wanjohi <sam.wanjohi94@gmail.com>
Date: Wed, 25 Jun 2025 20:38:12 +0300
Subject: [PATCH 4/7] Refactor

---
 .../Query/Container/TruncatedCollectionOfT.cs                  | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
index 13a373ae..6bbfdd12 100644
--- a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
+++ b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
@@ -308,8 +308,9 @@ public int Count
             }
             else if (_asyncSource != null)
             {
-                throw new InvalidOperationException("Count cannot be accessed synchronously for an asynchronous source. Use CountAsync instead.");
+                throw Error.InvalidOperation("Count cannot be accessed synchronously for an asynchronous source. Use CountAsync instead.");
             }
+
             return 0;
         }
     }

From e54873dfa882f4f23fed84995b539d61ef94496d Mon Sep 17 00:00:00 2001
From: Samuel Wanjohi <sam.wanjohi94@gmail.com>
Date: Thu, 26 Jun 2025 13:25:01 +0300
Subject: [PATCH 5/7] Try handling IAsyncEnumerable

---
 .../Microsoft.AspNetCore.OData.xml            | 92 +++----------------
 .../PublicAPI.Unshipped.txt                   | 12 ---
 .../Container/TruncatedAsyncEnumerableOfT.cs  | 71 ++++++++++++++
 .../Query/Container/TruncatedCollectionOfT.cs | 76 ++++-----------
 .../Container/TruncatedCollectionOfTTest.cs   |  4 +-
 5 files changed, 107 insertions(+), 148 deletions(-)
 create mode 100644 src/Microsoft.AspNetCore.OData/Query/Container/TruncatedAsyncEnumerableOfT.cs

diff --git a/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.xml b/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.xml
index abbb3fe9..14483fa3 100644
--- a/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.xml
+++ b/src/Microsoft.AspNetCore.OData/Microsoft.AspNetCore.OData.xml
@@ -8914,24 +8914,6 @@
             </summary>
             <typeparam name="T">The collection element type.</typeparam>
         </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Collections.Generic.List{`0},System.Int32,System.Nullable{System.Int64},System.Boolean)">
-            <summary>
-            Private constructor used by static Create methods and public constructors.
-            </summary>
-            <param name="items">The list of items in the collection.</param>
-            <param name="pageSize">The maximum number of items per page.</param>
-            <param name="totalCount">The total number of items in the source collection, if known.</param>
-            <param name="isTruncated">Indicates whether the collection is truncated.</param>
-        </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Collections.Generic.IAsyncEnumerable{`0},System.Int32,System.Nullable{System.Int64},System.Boolean)">
-            <summary>
-            Private constructor used by static Create methods and public constructors.
-            </summary>
-            <param name="asyncSource">The asynchronous source of items (pageSize + 1) in the collection.</param>
-            <param name="pageSize">The maximum number of items per page.</param>
-            <param name="totalCount">The total number of items in the source collection, if known.</param>
-            <param name="isTruncated">Indicates whether the collection is truncated.</param>
-        </member>
         <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Int32)">
             <summary>
             Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
@@ -8939,14 +8921,6 @@
             <param name="source">The collection to be truncated.</param>
             <param name="pageSize">The page size.</param>
         </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Int32,System.Nullable{System.Int64})">
-            <summary>
-            Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
-            </summary>
-            <param name="source">The queryable collection to be truncated.</param>
-            <param name="pageSize">The page size.</param>
-            <param name="totalCount">The total count.</param>
-        </member>
         <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Linq.IQueryable{`0},System.Int32)">
             <summary>
             Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
@@ -8962,75 +8936,39 @@
             <param name="pageSize">The page size.</param>
             <param name="parameterize">Flag indicating whether constants should be parameterized</param>
         </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection{`0})">
-            <summary>
-            Wrapper used internally by the backward-compatible constructors.
-            </summary>
-            <param name="other">An instance of <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/>.</param>
-        </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Collections.Generic.IEnumerable{`0},System.Int32)">
-            <summary>
-            Create a truncated collection from an <see cref="T:System.Collections.Generic.IEnumerable`1"/>.
-            </summary>
-            <param name="source">The collection to be truncated.</param>
-            <param name="pageSize">The page size.</param>
-            <returns>An instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"></see></returns>
-        </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Collections.Generic.IEnumerable{`0},System.Int32,System.Nullable{System.Int64})">
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Collections.Generic.IEnumerable{`0},System.Int32,System.Nullable{System.Int64})">
             <summary>
-            Create a truncated collection from an <see cref="T:System.Collections.Generic.IEnumerable`1"/>.
+            Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
             </summary>
-            <param name="source">The collection to be truncated.</param>
+            <param name="source">The queryable collection to be truncated.</param>
             <param name="pageSize">The page size.</param>
             <param name="totalCount">The total count.</param>
-            <returns>An instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"></see></returns>
         </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Linq.IQueryable{`0},System.Int32)">
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Linq.IQueryable{`0},System.Int32,System.Nullable{System.Int64})">
             <summary>
-            Create a truncated collection from an <see cref="T:System.Linq.IQueryable`1"/>.
-            </summary>
-            <param name="source">The collection to be truncated.</param>
-            <param name="pageSize">The page size.</param>
-            <returns>An instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"></see></returns>
-        </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Linq.IQueryable{`0},System.Int32,System.Nullable{System.Int64})">
-            <summary>
-            Create a truncated collection from an <see cref="T:System.Linq.IQueryable`1"/>.
+            Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
             </summary>
-            <param name="source">The collection to be truncated.</param>
+            <param name="source">The queryable collection to be truncated.</param>
             <param name="pageSize">The page size.</param>
             <param name="totalCount">The total count.</param>
-            <returns>An instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"></see></returns>
         </member>
-        <!-- Badly formed XML comment ignored for member "M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Linq.IQueryable{`0},System.Int32,System.Boolean)" -->
-        <!-- Badly formed XML comment ignored for member "M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Create(System.Linq.IQueryable{`0},System.Int32,System.Nullable{System.Int64},System.Boolean)" -->
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.CreateAsync(System.Collections.Generic.IAsyncEnumerable{`0},System.Int32,System.Nullable{System.Int64},System.Threading.CancellationToken)">
+        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.#ctor(System.Linq.IQueryable{`0},System.Int32,System.Nullable{System.Int64},System.Boolean)">
             <summary>
-            Create an async truncated collection from an <see cref="T:System.Collections.Generic.IAsyncEnumerable`1"/>.
+            Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/> class.
             </summary>
-            <param name="source">The AsyncEnumerable to be truncated.</param>
+            <param name="source">The queryable collection to be truncated.</param>
             <param name="pageSize">The page size.</param>
-            <param name="totalCount">The total count. Default is null.</param>
-            <param name="cancellationToken">Cancellation token for async operations. Default is <see cref="!:default"/></param>
-            <returns>An instance of the <see cref="T:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1"/></returns>
+            <param name="totalCount">The total count.</param>
+            <param name="parameterize">Flag indicating whether constants should be parameterized</param>
         </member>
         <member name="P:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.PageSize">
-            <inheritdoc/>
-        </member>
-        <member name="P:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.TotalCount">
-            <inheritdoc/>
+            <inheritdoc />
         </member>
         <member name="P:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.IsTruncated">
-            <inheritdoc/>
-        </member>
-        <member name="P:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.Count">
-            <inheritdoc/>
-        </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.GetEnumerator">
-            <inheritdoc/>
+            <inheritdoc />
         </member>
-        <member name="M:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.GetAsyncEnumerator(System.Threading.CancellationToken)">
-            <inheritdoc/>
+        <member name="P:Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection`1.TotalCount">
+            <inheritdoc />
         </member>
         <member name="T:Microsoft.AspNetCore.OData.Query.DefaultODataQueryRequestParser">
             <summary>
diff --git a/src/Microsoft.AspNetCore.OData/PublicAPI.Unshipped.txt b/src/Microsoft.AspNetCore.OData/PublicAPI.Unshipped.txt
index 579ce601..18bac592 100644
--- a/src/Microsoft.AspNetCore.OData/PublicAPI.Unshipped.txt
+++ b/src/Microsoft.AspNetCore.OData/PublicAPI.Unshipped.txt
@@ -44,11 +44,6 @@ Microsoft.AspNetCore.OData.ODataMiniOptions.SetVersion(Microsoft.OData.ODataVers
 Microsoft.AspNetCore.OData.ODataMiniOptions.SkipToken() -> Microsoft.AspNetCore.OData.ODataMiniOptions
 Microsoft.AspNetCore.OData.ODataMiniOptions.TimeZone.get -> System.TimeZoneInfo
 Microsoft.AspNetCore.OData.ODataMiniOptions.Version.get -> Microsoft.OData.ODataVersion
-Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Count.get -> int
-Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.CountAsync() -> System.Threading.Tasks.Task<int>
-Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.GetAsyncEnumerator(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Generic.IAsyncEnumerator<T>
-Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.GetEnumerator() -> System.Collections.Generic.IEnumerator<T>
-Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.this[int index].get -> T
 Microsoft.AspNetCore.OData.Query.IODataQueryEndpointFilter
 Microsoft.AspNetCore.OData.Query.IODataQueryEndpointFilter.OnFilterExecutedAsync(object responseValue, Microsoft.AspNetCore.OData.Extensions.ODataQueryFilterInvocationContext context) -> System.Threading.Tasks.ValueTask<object>
 Microsoft.AspNetCore.OData.Query.IODataQueryEndpointFilter.OnFilterExecutingAsync(Microsoft.AspNetCore.OData.Extensions.ODataQueryFilterInvocationContext context) -> System.Threading.Tasks.ValueTask
@@ -83,13 +78,6 @@ static Microsoft.AspNetCore.OData.ODataEndpointConventionBuilderExtensions.WithO
 static Microsoft.AspNetCore.OData.ODataEndpointConventionBuilderExtensions.WithODataVersion<TBuilder>(this TBuilder builder, Microsoft.OData.ODataVersion version) -> TBuilder
 static Microsoft.AspNetCore.OData.ODataServiceCollectionExtensions.AddOData(this Microsoft.Extensions.DependencyInjection.IServiceCollection services) -> Microsoft.Extensions.DependencyInjection.IServiceCollection
 static Microsoft.AspNetCore.OData.ODataServiceCollectionExtensions.AddOData(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Action<Microsoft.AspNetCore.OData.ODataMiniOptions> setupAction) -> Microsoft.Extensions.DependencyInjection.IServiceCollection
-static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Collections.Generic.IEnumerable<T> source, int pageSize) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
-static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Collections.Generic.IEnumerable<T> source, int pageSize, long? totalCount) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
-static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Linq.IQueryable<T> source, int pageSize) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
-static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Linq.IQueryable<T> source, int pageSize, bool parameterize) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
-static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Linq.IQueryable<T> source, int pageSize, long? totalCount) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
-static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.Create(System.Linq.IQueryable<T> source, int pageSize, long? totalCount, bool parameterize) -> Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>
-static Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>.CreateAsync(System.Collections.Generic.IAsyncEnumerable<T> source, int pageSize, long? totalCount = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<Microsoft.AspNetCore.OData.Query.Container.TruncatedCollection<T>>
 static Microsoft.AspNetCore.OData.Query.ODataQueryOptions<TEntity>.BindAsync(Microsoft.AspNetCore.Http.HttpContext context, System.Reflection.ParameterInfo parameter) -> System.Threading.Tasks.ValueTask<Microsoft.AspNetCore.OData.Query.ODataQueryOptions<TEntity>>
 static Microsoft.AspNetCore.OData.Query.ODataQueryOptions<TEntity>.PopulateMetadata(System.Reflection.ParameterInfo parameter, Microsoft.AspNetCore.Builder.EndpointBuilder builder) -> void
 static readonly Microsoft.AspNetCore.OData.Query.Wrapper.SelectExpandWrapperConverter.MapperProvider -> System.Func<Microsoft.OData.Edm.IEdmModel, Microsoft.OData.Edm.IEdmStructuredType, Microsoft.AspNetCore.OData.Query.Container.IPropertyMapper>
diff --git a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedAsyncEnumerableOfT.cs b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedAsyncEnumerableOfT.cs
new file mode 100644
index 00000000..54c24120
--- /dev/null
+++ b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedAsyncEnumerableOfT.cs
@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------------
+// <copyright file="TruncatedAsyncEnumerableOfT.cs" company=".NET Foundation">
+//      Copyright (c) .NET Foundation and Contributors. All rights reserved.
+//      See License.txt in the project root for license information.
+// </copyright>
+//------------------------------------------------------------------------------
+
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNetCore.OData.Query.Container;
+
+public class TruncatedAsyncEnumerable<T> : IAsyncEnumerable<T>
+{
+    private readonly IAsyncEnumerable<T> _source;
+    private readonly int _pageSize;
+    private readonly TruncationState _state;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TruncatedAsyncEnumerable{T}"/> class, which provides an
+    /// asynchronous enumerable that limits the number of items returned per page and tracks truncation state.
+    /// </summary>
+    /// <param name="source">The source asynchronous enumerable to be paginated and truncated.</param>
+    /// <param name="pageSize">The maximum number of items to include in each page. Must be greater than zero.</param>
+    /// <param name="state">The truncation state object used to track whether the enumeration was truncated.</param>
+    public TruncatedAsyncEnumerable(IAsyncEnumerable<T> source, int pageSize, TruncationState state)
+    {
+        _source = source;
+        _pageSize = pageSize;
+        _state = state;
+    }
+
+    /// <summary>
+    /// Returns an asynchronous enumerator that iterates through the items in the source collection,  up to a specified page size.
+    /// </summary>
+    /// <remarks>The enumerator yields items from the source collection until the specified page size is reached.  
+    /// If the number of items exceeds the page size, the enumeration is truncated, and the state is updated to true. Otherwise, the state is updated to false.</remarks>
+    /// <param name="cancellationToken">A token to monitor for cancellation requests. If the token is canceled, the enumeration is stopped.</param>
+    /// <returns>An asynchronous enumerator that yields items from the source collection, up to the specified page size.</returns>
+    public async IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+    {
+        int count = 0;
+        await foreach (var item in _source.WithCancellation(cancellationToken))
+        {
+            if (count < _pageSize)
+            {
+                yield return item;
+                count++;
+            }
+            else
+            {
+                // More items exist than pageSize, so mark as truncated and stop yielding.
+                _state.IsTruncated = true;
+                yield break;
+            }
+        }
+
+        // If we didn't hit the limit, not truncated.
+        _state.IsTruncated = false;
+    }
+}
+
+
+/// <summary>
+/// Used to track the truncation state of an async enumerable.
+/// </summary>
+public class TruncationState
+{
+    public bool IsTruncated { get; set; }
+}
diff --git a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
index 6bbfdd12..dbe054e7 100644
--- a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
+++ b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
@@ -28,6 +28,8 @@ public class TruncatedCollection<T> : IReadOnlyList<T>, ITruncatedCollection, IC
 
     private readonly bool _isTruncated;
 
+    private readonly TruncationState _isTruncatedState;
+
     /// <summary>
     /// Private constructor used by static Create methods and public constructors.
     /// </summary>
@@ -49,11 +51,11 @@ private TruncatedCollection(List<T> items, int pageSize, long? totalCount, bool
     /// <param name="asyncSource">The asynchronous source of items (pageSize + 1) in the collection.</param>
     /// <param name="pageSize">The maximum number of items per page.</param>
     /// <param name="totalCount">The total number of items in the source collection, if known.</param>
-    /// <param name="isTruncated">Indicates whether the collection is truncated.</param>
-    private TruncatedCollection(IAsyncEnumerable<T> asyncSource, int pageSize, long? totalCount, bool isTruncated)
+    /// <param name="isTruncatedState">State to indicate whether the collection is truncated.</param>
+    private TruncatedCollection(IAsyncEnumerable<T> asyncSource, int pageSize, long? totalCount, TruncationState isTruncatedState)
     {
         _asyncSource = asyncSource;
-        _isTruncated = isTruncated;
+        _isTruncatedState = isTruncatedState;
         PageSize = pageSize;
         TotalCount = totalCount;
     }
@@ -184,12 +186,12 @@ public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize,
     /// </summary>
     /// <param name="source">The AsyncEnumerable to be truncated.</param>
     /// <param name="pageSize">The page size.</param>
-    /// <param name="totalCount">The total count. Default is null.</param>
+    /// /// <param name="totalCount">The total count. Default null.</param>
     /// <param name="cancellationToken">Cancellation token for async operations. Default.</param>
     /// <returns>An instance of the <see cref="TruncatedCollection{T}"/></returns>
-    public static async Task<TruncatedCollection<T>> CreateAsync(IAsyncEnumerable<T> source, int pageSize, long? totalCount = null, CancellationToken cancellationToken = default)
+    public static TruncatedCollection<T> CreateForAsyncSource(IAsyncEnumerable<T> source, int pageSize, long? totalCount = null, CancellationToken cancellationToken = default)
     {
-        return await CreateInternalAsync(source, pageSize, totalCount, cancellationToken).ConfigureAwait(false);
+        return CreateInternal(source, pageSize, totalCount, cancellationToken);
     }
 
     #endregion
@@ -235,41 +237,15 @@ private static TruncatedCollection<T> CreateInternal(IQueryable<T> source, int p
         return new TruncatedCollection<T>(buffer, pageSize, totalCount, isTruncated: enumerator.MoveNext());
     }
 
-    private static async Task<TruncatedCollection<T>> CreateInternalAsync(IAsyncEnumerable<T> source, int pageSize, long? totalCount, CancellationToken cancellationToken)
+    private static TruncatedCollection<T> CreateInternal(IAsyncEnumerable<T> source, int pageSize, long? totalCount, CancellationToken cancellationToken = default)
     {
         ValidateArgs(source, pageSize);
 
         int capacity = pageSize > 0 ? pageSize : (totalCount > 0 ? (totalCount < int.MaxValue ? (int)totalCount : int.MaxValue) : DefaultCapacity);
-        var buffer = new List<T>(capacity);
-
-        bool isTruncated = false;
-        int count = 0;
-        await foreach (var item in source.Take(checked(capacity + 1)).WithCancellation(cancellationToken).ConfigureAwait(false))
-        {
-            if (count < pageSize)
-            {
-                buffer.Add(item);
-                count++;
-            }
-            else
-            {
-                isTruncated = true;
-                break;
-            }
-        }
-
-        // Create a new async enumerable from the buffer
-        IAsyncEnumerable<T> truncatedSource = GetAsyncEnumerable(buffer);
-
-        return new TruncatedCollection<T>(truncatedSource, pageSize, totalCount, isTruncated);
 
-        static async IAsyncEnumerable<T> GetAsyncEnumerable(IEnumerable<T> items)
-        {
-            foreach (var item in items)
-                yield return item;
-
-            await Task.CompletedTask;
-        }
+        var state = new TruncationState();
+        var truncatedSource = new TruncatedAsyncEnumerable<T>(source, capacity, state);
+        return new TruncatedCollection<T>(truncatedSource, pageSize, totalCount, state);
     }
 
     private static IQueryable<T> Take(IQueryable<T> source, int pageSize, bool parameterize)
@@ -295,7 +271,7 @@ private static void ValidateArgs(object source, int pageSize)
     /// <inheritdoc/>
     public long? TotalCount { get; }
     /// <inheritdoc/>
-    public bool IsTruncated => _isTruncated;
+    public bool IsTruncated => _isTruncatedState?.IsTruncated ?? _isTruncated;
 
     /// <inheritdoc/>
     public int Count
@@ -324,13 +300,9 @@ public async Task<int> CountAsync()
         }
         else if (_asyncSource != null)
         {
-            int count = 0;
-            await foreach (var _ in _asyncSource.ConfigureAwait(false))
-            {
-                count++;
-            }
-            return count;
+            return await _asyncSource.CountAsync().ConfigureAwait(false);
         }
+
         return 0;
     }
 
@@ -338,20 +310,10 @@ public async Task<int> CountAsync()
     public T this[int index] => _items[index];
 
     /// <inheritdoc/>
-    public IEnumerator<T> GetEnumerator() => _items.GetEnumerator();
-    IEnumerator IEnumerable.GetEnumerator() => _items.GetEnumerator();
+    public IEnumerator<T> GetEnumerator() => _items?.GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => _items?.GetEnumerator();
 
     /// <inheritdoc/>
-    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
-    {
-        return GetPagedAsyncEnumerator(cancellationToken);
-
-        async IAsyncEnumerator<T> GetPagedAsyncEnumerator(CancellationToken ct)
-        {
-            await foreach (var item in _asyncSource.WithCancellation(ct).ConfigureAwait(false))
-            {
-                yield return item;
-            }
-        }
-    }
+    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default) =>
+        _asyncSource?.GetAsyncEnumerator(cancellationToken);
 }
diff --git a/test/Microsoft.AspNetCore.OData.Tests/Query/Container/TruncatedCollectionOfTTest.cs b/test/Microsoft.AspNetCore.OData.Tests/Query/Container/TruncatedCollectionOfTTest.cs
index 2c36c0b1..1ac59cb2 100644
--- a/test/Microsoft.AspNetCore.OData.Tests/Query/Container/TruncatedCollectionOfTTest.cs
+++ b/test/Microsoft.AspNetCore.OData.Tests/Query/Container/TruncatedCollectionOfTTest.cs
@@ -71,14 +71,14 @@ public async Task TruncatedCollectionCreateForIAsyncEnumerable_SetsProperties()
     {
         // Arrange & Act
         IAsyncEnumerable<int> source = new[] { 1, 2, 3, 5, 7 }.ToAsyncEnumerable();
-        var collection = await TruncatedCollection<int>.CreateAsync(source, 3, 5);
+        var collection = TruncatedCollection<int>.CreateForAsyncSource(source, 3, 5);
 
         // Assert
         Assert.Equal(3, collection.PageSize);
         Assert.Equal(5, collection.TotalCount);
-        Assert.True(collection.IsTruncated);
         Assert.Equal(3, await collection.CountAsync());
         Assert.Equal(new[] { 1, 2, 3 }, await collection.ToArrayAsync());
+        Assert.True(collection.IsTruncated);
     }
 
     [Fact]

From f2ef42198557a7d57f550d8851babc5563ee3575 Mon Sep 17 00:00:00 2001
From: Samuel Wanjohi <WanjohiSammy@users.noreply.github.com>
Date: Thu, 26 Jun 2025 14:10:24 +0300
Subject: [PATCH 6/7] Update
 src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 .../Query/Container/TruncatedCollectionOfT.cs          | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
index dbe054e7..1dddf25f 100644
--- a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
+++ b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
@@ -314,6 +314,12 @@ public async Task<int> CountAsync()
     IEnumerator IEnumerable.GetEnumerator() => _items?.GetEnumerator();
 
     /// <inheritdoc/>
-    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default) =>
-        _asyncSource?.GetAsyncEnumerator(cancellationToken);
+    public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+    {
+        if (_asyncSource == null)
+        {
+            throw new InvalidOperationException("Async enumeration is not supported for sync-only instances.");
+        }
+        return _asyncSource.GetAsyncEnumerator(cancellationToken);
+    }
 }

From 9a885d9110c6e4f405f9efa3cfd87e371107eb69 Mon Sep 17 00:00:00 2001
From: Samuel Wanjohi <sam.wanjohi94@gmail.com>
Date: Fri, 4 Jul 2025 09:49:46 +0300
Subject: [PATCH 7/7] some refactor

---
 .../Query/Container/TruncatedAsyncEnumerableOfT.cs              | 2 +-
 .../Query/Container/TruncatedCollectionOfT.cs                   | 2 +-
 .../IAsyncEnumerableTests/IAsyncEnumerableController.cs         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedAsyncEnumerableOfT.cs b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedAsyncEnumerableOfT.cs
index 54c24120..0ce6a4fb 100644
--- a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedAsyncEnumerableOfT.cs
+++ b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedAsyncEnumerableOfT.cs
@@ -32,7 +32,7 @@ public TruncatedAsyncEnumerable(IAsyncEnumerable<T> source, int pageSize, Trunca
     }
 
     /// <summary>
-    /// Returns an asynchronous enumerator that iterates through the items in the source collection,  up to a specified page size.
+    /// Returns an asynchronous enumerator that iterates through the items in the source collection, up to a specified page size.
     /// </summary>
     /// <remarks>The enumerator yields items from the source collection until the specified page size is reached.  
     /// If the number of items exceeds the page size, the enumeration is truncated, and the state is updated to true. Otherwise, the state is updated to false.</remarks>
diff --git a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
index dbe054e7..413ce373 100644
--- a/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
+++ b/src/Microsoft.AspNetCore.OData/Query/Container/TruncatedCollectionOfT.cs
@@ -189,7 +189,7 @@ public static TruncatedCollection<T> Create(IQueryable<T> source, int pageSize,
     /// /// <param name="totalCount">The total count. Default null.</param>
     /// <param name="cancellationToken">Cancellation token for async operations. Default.</param>
     /// <returns>An instance of the <see cref="TruncatedCollection{T}"/></returns>
-    public static TruncatedCollection<T> CreateForAsyncSource(IAsyncEnumerable<T> source, int pageSize, long? totalCount = null, CancellationToken cancellationToken = default)
+    public static TruncatedCollection<T> CreateForAsync(IAsyncEnumerable<T> source, int pageSize, long? totalCount = null, CancellationToken cancellationToken = default)
     {
         return CreateInternal(source, pageSize, totalCount, cancellationToken);
     }
diff --git a/test/Microsoft.AspNetCore.OData.E2E.Tests/IAsyncEnumerableTests/IAsyncEnumerableController.cs b/test/Microsoft.AspNetCore.OData.E2E.Tests/IAsyncEnumerableTests/IAsyncEnumerableController.cs
index e73e29c1..dced0d04 100644
--- a/test/Microsoft.AspNetCore.OData.E2E.Tests/IAsyncEnumerableTests/IAsyncEnumerableController.cs
+++ b/test/Microsoft.AspNetCore.OData.E2E.Tests/IAsyncEnumerableTests/IAsyncEnumerableController.cs
@@ -55,7 +55,7 @@ public ActionResult<IAsyncEnumerable<Customer>> CustomersDataNew()
         return Ok(_context.Customers.AsAsyncEnumerable());
     }
 
-    [EnableQuery]
+    [EnableQuery(PageSize = 2)]
     [HttpGet("v3/Customers")]
     public IActionResult SearchCustomersForV3Route([FromQuery] Variant variant = Variant.None)
     {