Improve Count(predicate) from array performance

Author: neuecc

sandbox/Benchmark/Benchmarks/AllAnyPredicateWithCapturedLambda.cs

@@ -79,3 +79,34 @@ public bool Linq()
         return _nums.All(i => i <= _target);
     }
 }
+
+[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
+public class CountPredicateWithCapturedLambda
+{
+    [Params(10, 100, 1000, 10000)]
+    public int N;
+
+    int[] _nums = default!;
+    int _target;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _nums = Enumerable.Range(1, N).ToArray();
+        _target = N;
+    }
+
+    [Benchmark]
+    [BenchmarkCategory(Categories.ZLinq)]
+    public int ZLinq()
+    {
+        return _nums.AsValueEnumerable().Count(i => i <= _target);
+    }
+
+    [Benchmark]
+    [BenchmarkCategory(Categories.LINQ)]
+    public int Linq()
+    {
+        return _nums.Count(i => i <= _target);
+    }
+}

sandbox/Benchmark/Properties/launchSettings.json

@@ -2,7 +2,7 @@
   "profiles": {
     "Default": {
       "commandName": "Project",
-      "commandLineArgs": "--filter Benchmark.AllPredicateWithCapturedLambda* -- Default",
+      "commandLineArgs": "--filter Benchmark.CountPredicateWithCapturedLambda* -- Default",
 
       // Available config
       // 1. Default

src/ZLinq/Linq/Count.cs

@@ -63,5 +63,46 @@ public static Int32 Count<TEnumerator, TSource>(this ValueEnumerable<TEnumerator
 
             return count;
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Int32 Count<TSource>(this ValueEnumerable<FromArray<TSource>, TSource> source, Func<TSource, Boolean> predicate)
+        {
+            ArgumentNullException.ThrowIfNull(predicate);
+
+            var array = source.Enumerator.GetSource();
+            if (array.GetType() != typeof(TSource[]))
+            {
+                return Count(array, predicate);
+            }
+
+            var count = 0;
+
+            // The assembly output differs slightly when iterating through array and span.
+            // According to microbenckmark results, iterating through span was faster for the logic passed to predicate.
+            var span = (ReadOnlySpan<TSource>)array;
+            for (int i = 0; i < span.Length; i++)
+            {
+                if (predicate(span[i]))
+                {
+                    count++;
+                }
+            }
+
+            return count;
+
+            [MethodImpl(MethodImplOptions.NoInlining)]
+            static int Count(TSource[] array, Func<TSource, Boolean> predicate)
+            {
+                var count = 0;
+                for (int i = 0; i < array.Length; i++)
+                {
+                    if (predicate(array[i]))
+                    {
+                        count++;
+                    }
+                }
+                return count;
+            }
+        }
     }
 }