Add Enumerable.TryGetNonEnumeratedCount (Implements #27183)

src/libraries/Common/src/System/Collections/Generic/EnumerableHelpers.Linq.cs

@@ -11,32 +11,6 @@ namespace System.Collections.Generic
     /// </summary>
     internal static partial class EnumerableHelpers
     {
-        /// <summary>
-        /// Tries to get the count of the enumerable cheaply.
-        /// </summary>
-        /// <typeparam name="T">The element type of the source enumerable.</typeparam>
-        /// <param name="source">The enumerable to count.</param>
-        /// <param name="count">The count of the enumerable, if it could be obtained cheaply.</param>
-        /// <returns><c>true</c> if the enumerable could be counted cheaply; otherwise, <c>false</c>.</returns>
-        internal static bool TryGetCount<T>(IEnumerable<T> source, out int count)
-        {
-            Debug.Assert(source != null);
-
-            if (source is ICollection<T> collection)
-            {
-                count = collection.Count;
-                return true;
-            }
-
-            if (source is IIListProvider<T> provider)
-            {
-                return (count = provider.GetCount(onlyIfCheap: true)) >= 0;
-            }
-
-            count = -1;
-            return false;
-        }
-
         /// <summary>
         /// Copies items from an enumerable to an array.
         /// </summary>

src/libraries/Common/src/System/Collections/Generic/SparseArrayBuilder.cs

@@ -190,7 +190,7 @@ public void Reserve(int count)
         public bool ReserveOrAdd(IEnumerable<T> items)
         {
             int itemCount;
-            if (EnumerableHelpers.TryGetCount(items, out itemCount))
+            if (System.Linq.Enumerable.TryGetNonEnumeratedCount(items, out itemCount))
             {
                 if (itemCount > 0)
                 {

src/libraries/System.Linq.Queryable/tests/Queryable.cs

@@ -121,16 +121,17 @@ public static void MatchSequencePattern()
                 typeof(Enumerable),
                 typeof(Queryable),
                  new [] {
-                     "ToLookup",
-                     "ToDictionary",
-                     "ToArray",
-                     "AsEnumerable",
-                     "ToList",
+                     nameof(Enumerable.ToLookup),
+                     nameof(Enumerable.ToDictionary),
+                     nameof(Enumerable.ToArray),
+                     nameof(Enumerable.AsEnumerable),
+                     nameof(Enumerable.ToList),
+                     nameof(Enumerable.Append),
+                     nameof(Enumerable.Prepend),
+                     nameof(Enumerable.ToHashSet),
+                     nameof(Enumerable.TryGetNonEnumeratedCount),
                      "Fold",
                      "LeftJoin",
-                     "Append",
-                     "Prepend",
-                     "ToHashSet"
                  }
                 );
 
@@ -140,7 +141,7 @@ public static void MatchSequencePattern()
                 typeof(Queryable),
                 typeof(Enumerable),
                  new [] {
-                     "AsQueryable"
+                     nameof(Queryable.AsQueryable)
                  }
                 );
 

src/libraries/System.Linq/Directory.Build.props

@@ -3,4 +3,4 @@
   <PropertyGroup>
     <StrongNameKeyId>Microsoft</StrongNameKeyId>
   </PropertyGroup>
-</Project>
+</Project>

src/libraries/System.Linq/ref/System.Linq.cs

@@ -189,6 +189,7 @@ public static System.Collections.Generic.IEnumerable<
         public static System.Linq.ILookup<TKey, TSource> ToLookup<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
         public static System.Linq.ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector) { throw null; }
         public static System.Linq.ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        public static bool TryGetNonEnumeratedCount<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, out int count) { throw null; }
         public static System.Collections.Generic.IEnumerable<TSource> Union<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second) { throw null; }
         public static System.Collections.Generic.IEnumerable<TSource> Union<TSource>(this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second, System.Collections.Generic.IEqualityComparer<TSource>? comparer) { throw null; }
         public static System.Collections.Generic.IEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { throw null; }

src/libraries/System.Linq/src/System/Linq/Concat.SpeedOpt.cs

@@ -13,7 +13,7 @@ private sealed partial class Concat2Iterator<TSource> : ConcatIterator<TSource>
             public override int GetCount(bool onlyIfCheap)
             {
                 int firstCount, secondCount;
-                if (!EnumerableHelpers.TryGetCount(_first, out firstCount))
+                if (!_first.TryGetNonEnumeratedCount(out firstCount))
                 {
                     if (onlyIfCheap)
                     {
@@ -23,7 +23,7 @@ public override int GetCount(bool onlyIfCheap)
                     firstCount = _first.Count();
                 }
 
-                if (!EnumerableHelpers.TryGetCount(_second, out secondCount))
+                if (!_second.TryGetNonEnumeratedCount(out secondCount))
                 {
                     if (onlyIfCheap)
                     {

src/libraries/System.Linq/src/System/Linq/Count.cs

@@ -72,6 +72,59 @@ public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource,
             return count;
         }
 
+        /// <summary>
+        ///   Attempts to determine the number of elements in a sequence without forcing an enumeration.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+        /// <param name="source">A sequence that contains elements to be counted.</param>
+        /// <param name="count">
+        ///     When this method returns, contains the count of <paramref name="source" /> if successful,
+        ///     or zero if the method failed to determine the count.</param>
+        /// <returns>
+        ///   <see langword="true" /> if the count of <paramref name="source"/> can be determined without enumeration;
+        ///   otherwise, <see langword="false" />.
+        /// </returns>
+        /// <remarks>
+        ///   The method performs a series of type tests, identifying common subtypes whose
+        ///   count can be determined without enumerating; this includes <see cref="ICollection{T}"/>,
+        ///   <see cref="ICollection"/> as well as internal types used in the LINQ implementation.
+        ///
+        ///   The method is typically a constant-time operation, but ultimately this depends on the complexity
+        ///   characteristics of the underlying collection implementation.
+        /// </remarks>
+        public static bool TryGetNonEnumeratedCount<TSource>(this IEnumerable<TSource> source, out int count)
+        {
+            if (source == null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.source);
+            }
+
+            if (source is ICollection<TSource> collectionoft)
+            {
+                count = collectionoft.Count;
+                return true;
+            }
+
+            if (source is IIListProvider<TSource> listProv)
+            {
+                int c = listProv.GetCount(onlyIfCheap: true);
+                if (c >= 0)
+                {
+                    count = c;
+                    return true;
+                }
+            }
+
+            if (source is ICollection collection)
+            {
+                count = collection.Count;
+                return true;
+            }
+
+            count = 0;
+            return false;
+        }
+
         public static long LongCount<TSource>(this IEnumerable<TSource> source)
         {
             if (source == null)

src/libraries/System.Linq/tests/ConsistencyTests.cs

@@ -41,9 +41,10 @@ private static IEnumerable<string> GetExcludedMethods()
                 nameof(Enumerable.ToArray),
                 nameof(Enumerable.AsEnumerable),
                 nameof(Enumerable.ToList),
+                nameof(Enumerable.ToHashSet),
+                nameof(Enumerable.TryGetNonEnumeratedCount),
                 "Fold",
                 "LeftJoin",
-                "ToHashSet"
             };
 
             return result;

src/libraries/System.Linq/tests/CountTests.cs

@@ -126,5 +126,89 @@ public void NullPredicate_ThrowsArgumentNullException()
             Func<int, bool> predicate = null;
             AssertExtensions.Throws<ArgumentNullException>("predicate", () => Enumerable.Range(0, 3).Count(predicate));
         }
+
+        [Fact]
+        public void NonEnumeratingCount_NullSource_ThrowsArgumentNullException()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("source", () => ((IEnumerable<int>)null).TryGetNonEnumeratedCount(out _));
+        }
+
+        [Theory]
+        [MemberData(nameof(NonEnumeratingCount_SupportedEnumerables))]
+        public void NonEnumeratingCount_SupportedEnumerables_ShouldReturnExpectedCount<T>(int expectedCount, IEnumerable<T> source)
+        {
+            Assert.True(source.TryGetNonEnumeratedCount(out int actualCount));
+            Assert.Equal(expectedCount, actualCount);
+        }
+
+        [Theory]
+        [MemberData(nameof(NonEnumeratingCount_UnsupportedEnumerables))]
+        public void NonEnumeratingCount_UnsupportedEnumerables_ShouldReturnFalse<T>(IEnumerable<T> source)
+        {
+            Assert.False(source.TryGetNonEnumeratedCount(out int actualCount));
+            Assert.Equal(0, actualCount);
+        }
+
+        [Fact]
+        public void NonEnumeratingCount_ShouldNotEnumerateSource()
+        {
+            bool isEnumerated = false;
+            Assert.False(Source().TryGetNonEnumeratedCount(out int count));
+            Assert.Equal(0, count);
+            Assert.False(isEnumerated);
+
+            IEnumerable<int> Source()
+            {
+                isEnumerated = true;
+                yield return 42;
+            }
+        }
+
+        public static IEnumerable<object[]> NonEnumeratingCount_SupportedEnumerables()
+        {
+            yield return WrapArgs(4, new int[]{ 1, 2, 3, 4 });
+            yield return WrapArgs(4, new List<int>(new int[] { 1, 2, 3, 4 }));
+            yield return WrapArgs(4, new Stack<int>(new int[] { 1, 2, 3, 4 }));
+
+            yield return WrapArgs(0, Enumerable.Empty<string>());
+
+            if (PlatformDetection.IsSpeedOptimized)
+            {
+                yield return WrapArgs(100, Enumerable.Range(1, 100));
+                yield return WrapArgs(80, Enumerable.Repeat(1, 80));
+                yield return WrapArgs(50, Enumerable.Range(1, 50).Select(x => x + 1));
+                yield return WrapArgs(4, new int[] { 1, 2, 3, 4 }.Select(x => x + 1));
+                yield return WrapArgs(50, Enumerable.Range(1, 50).Select(x => x + 1).Select(x => x - 1));
+                yield return WrapArgs(7, Enumerable.Range(1, 20).ToLookup(x => x % 7));
+                yield return WrapArgs(20, Enumerable.Range(1, 20).Reverse());
+                yield return WrapArgs(20, Enumerable.Range(1, 20).OrderBy(x => -x));
+                yield return WrapArgs(20, Enumerable.Range(1, 10).Concat(Enumerable.Range(11, 10)));
+            }
+
+            static object[] WrapArgs<T>(int expectedCount, IEnumerable<T> source) => new object[] { expectedCount, source };
+        }
+
+        public static IEnumerable<object[]> NonEnumeratingCount_UnsupportedEnumerables()
+        {
+            yield return WrapArgs(Enumerable.Range(1, 100).Where(x => x % 2 == 0));
+            yield return WrapArgs(Enumerable.Range(1, 100).GroupBy(x => x % 2 == 0));
+            yield return WrapArgs(new Stack<int>(new int[] { 1, 2, 3, 4 }).Select(x => x + 1));
+            yield return WrapArgs(Enumerable.Range(1, 100).Distinct());
+
+            if (!PlatformDetection.IsSpeedOptimized)
+            {
+                yield return WrapArgs(Enumerable.Range(1, 100));
+                yield return WrapArgs(Enumerable.Repeat(1, 80));
+                yield return WrapArgs(Enumerable.Range(1, 50).Select(x => x + 1));
+                yield return WrapArgs(new int[] { 1, 2, 3, 4 }.Select(x => x + 1));            
+                yield return WrapArgs(Enumerable.Range(1, 50).Select(x => x + 1).Select(x => x - 1));
+                yield return WrapArgs(Enumerable.Range(1, 20).ToLookup(x => x % 7));
+                yield return WrapArgs(Enumerable.Range(1, 20).Reverse());
+                yield return WrapArgs(Enumerable.Range(1, 20).OrderBy(x => -x));
+                yield return WrapArgs(Enumerable.Range(1, 10).Concat(Enumerable.Range(11, 10)));
+            }
+
+            static object[] WrapArgs<T>(IEnumerable<T> source) => new object[] { source };
+        }
     }
 }