Feat: Add benchmarks for SpanLINQ extensions and scoped keyword

AnnaSasDev · AnnaSasDev · commit 8aeeb7b10e14 · 2025-08-13T14:42:23.000+02:00
diff --git a/CodeOfChaos.Extensions.sln b/CodeOfChaos.Extensions.sln
@@ -54,6 +54,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeOfChaos.Extensions.AspN
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests.CodeOfChaos.Extensions.AspNetCore.Components", "tests\Tests.CodeOfChaos.Extensions.AspNetCore.Components\Tests.CodeOfChaos.Extensions.AspNetCore.Components.csproj", "{0B45A069-2FF5-4BD0-BC53-CB63FE29E781}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Benchmarks.CodeOfChaos.Extensions", "tests\Benchmarks.CodeOfChaos.Extensions\Benchmarks.CodeOfChaos.Extensions.csproj", "{F1C463EA-E828-4E4A-ABF8-EE4908D1E1F8}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -152,6 +154,10 @@ Global
 		{0B45A069-2FF5-4BD0-BC53-CB63FE29E781}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0B45A069-2FF5-4BD0-BC53-CB63FE29E781}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0B45A069-2FF5-4BD0-BC53-CB63FE29E781}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F1C463EA-E828-4E4A-ABF8-EE4908D1E1F8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F1C463EA-E828-4E4A-ABF8-EE4908D1E1F8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F1C463EA-E828-4E4A-ABF8-EE4908D1E1F8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F1C463EA-E828-4E4A-ABF8-EE4908D1E1F8}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{26284571-0E09-4BAF-8C2B-DF87DCC1BA0B} = {8DD280D4-1E14-4D5E-AFE6-58DD8F079DCC}
@@ -177,5 +183,6 @@ Global
 		{E9BB7403-5167-46CA-BE84-F420CF28C910} = {197E72AD-DEAB-4350-AFC3-A3BB38720BF5}
 		{C5C64661-887A-4E19-93EB-F9D5765C635B} = {197E72AD-DEAB-4350-AFC3-A3BB38720BF5}
 		{0B45A069-2FF5-4BD0-BC53-CB63FE29E781} = {8DD280D4-1E14-4D5E-AFE6-58DD8F079DCC}
+		{F1C463EA-E828-4E4A-ABF8-EE4908D1E1F8} = {8DD280D4-1E14-4D5E-AFE6-58DD8F079DCC}
 	EndGlobalSection
 EndGlobal
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQAllExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQAllExtensions.cs
@@ -9,10 +9,10 @@ namespace CodeOfChaos.SpanLINQ;
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQAllExtensions {
     
-    public static bool All<T>(this in Span<T> span, Func<T, bool> predicate) 
+    public static bool All<T>(this scoped Span<T> span, Func<T, bool> predicate) 
         => All((ReadOnlySpan<T>)span, predicate);
     
-    public static bool All<T>(this in ReadOnlySpan<T> span, Func<T, bool> predicate) {
+    public static bool All<T>(this scoped ReadOnlySpan<T> span, Func<T, bool> predicate) {
         for (int i = span.Length - 1; i >= 0; i--)
             if (!predicate(span[i])) return false;
         return true;
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQAnyExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQAnyExtensions.cs
@@ -8,19 +8,19 @@ namespace CodeOfChaos.SpanLINQ;
 // ---------------------------------------------------------------------------------------------------------------------
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQAnyExtensions {
-    public static bool Any<T>(this in Span<T> span) 
+    public static bool Any<T>(this scoped Span<T> span) 
         => Any((ReadOnlySpan<T>)span);
     
-    public static bool Any<T>(this in ReadOnlySpan<T> span) {
+    public static bool Any<T>(this scoped ReadOnlySpan<T> span) {
         for (int i = span.Length - 1; i >= 0; i--)
             if (span[i] != null) return true;
         return false;
     }
     
-    public static bool Any<T>(this in Span<T> span, Func<T, bool> predicate) 
+    public static bool Any<T>(this scoped Span<T> span, Func<T, bool> predicate) 
         => Any((ReadOnlySpan<T>)span, predicate);
     
-    public static bool Any<T>(this in ReadOnlySpan<T> span, Func<T, bool> predicate) {
+    public static bool Any<T>(this scoped ReadOnlySpan<T> span, Func<T, bool> predicate) {
         for (int i = span.Length - 1; i >= 0; i--)
             if (predicate(span[i])) return true;
         return false;
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQAverageExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQAverageExtensions.cs
@@ -9,10 +9,10 @@ namespace System;
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQAverageExtensions {
     
-    public static double Average<T>(this in Span<T> span, Func<T, double> selector)
+    public static double Average<T>(this scoped Span<T> span, Func<T, double> selector)
         => Average((ReadOnlySpan<T>)span, selector);
 
-    public static double Average<T>(this in ReadOnlySpan<T> span, Func<T, double> selector) {
+    public static double Average<T>(this scoped ReadOnlySpan<T> span, Func<T, double> selector) {
         int length = span.Length;
         if (length == 0) throw new InvalidOperationException("Sequence contains no elements");
 
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQCountExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQCountExtensions.cs
@@ -10,10 +10,10 @@ namespace CodeOfChaos.SpanLINQ;
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQCountExtensions {
     
-    public static int Count<T>(this in Span<T> span, Func<T, bool> predicate) 
+    public static int Count<T>(this scoped Span<T> span, Func<T, bool> predicate) 
         => Count((ReadOnlySpan<T>)span, predicate);
     
-    public static int Count<T>(this in ReadOnlySpan<T> span, Func<T, bool> predicate) {
+    public static int Count<T>(this scoped ReadOnlySpan<T> span, Func<T, bool> predicate) {
         int count = 0;
         for (int index = span.Length - 1; index >= 0; index--) {
             if (predicate(span[index])) count++;
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQFirstExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQFirstExtensions.cs
@@ -9,10 +9,10 @@ namespace CodeOfChaos.SpanLINQ;
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQFirstExtensions {
     
-    public static T First<T>(this in Span<T> span, Func<T, bool> predicate)
+    public static T First<T>(this scoped Span<T> span, Func<T, bool> predicate)
         => First((ReadOnlySpan<T>)span, predicate);
 
-    public static T First<T>(this in ReadOnlySpan<T> span, Func<T, bool> predicate) {
+    public static T First<T>(this scoped ReadOnlySpan<T> span, Func<T, bool> predicate) {
         // ReSharper disable once ForCanBeConvertedToForeach
         for (int i = 0; i < span.Length; i++) {
             T element = span[i];
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQLastExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQLastExtensions.cs
@@ -9,10 +9,10 @@ namespace CodeOfChaos.SpanLINQ;
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQLastExtensions {
     
-    public static T Last<T>(this in Span<T> span, Func<T, bool> predicate) 
+    public static T Last<T>(this scoped Span<T> span, Func<T, bool> predicate) 
         => Last((ReadOnlySpan<T>)span, predicate);
     
-    public static T Last<T>(this in ReadOnlySpan<T> span, Func<T, bool> predicate) {
+    public static T Last<T>(this scoped ReadOnlySpan<T> span, Func<T, bool> predicate) {
         for (int i = span.Length - 1; i >= 0; i--) {
             T element = span[i];
             if (predicate(element)) return element;
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQMaxExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQMaxExtensions.cs
@@ -9,10 +9,10 @@ namespace CodeOfChaos.SpanLINQ;
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQMaxExtensions {
     
-    public static TResult Max<T, TResult>(this in Span<T> span, Func<T, TResult> selector) where TResult : IComparable<TResult> 
+    public static TResult Max<T, TResult>(this scoped Span<T> span, Func<T, TResult> selector) where TResult : IComparable<TResult> 
         => Max((ReadOnlySpan<T>)span, selector);
 
-    public static TResult Max<T, TResult>(this in ReadOnlySpan<T> span, Func<T, TResult> selector)
+    public static TResult Max<T, TResult>(this scoped ReadOnlySpan<T> span, Func<T, TResult> selector)
         where TResult : IComparable<TResult> {
         if (span.Length == 0) throw new InvalidOperationException("Sequence contains no elements");
 
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQMinExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQMinExtensions.cs
@@ -9,10 +9,10 @@ namespace CodeOfChaos.SpanLINQ;
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQMinExtensions {
     
-    public static TResult Min<T, TResult>(this in Span<T> span, Func<T, TResult> selector) where TResult : IComparable<TResult> 
+    public static TResult Min<T, TResult>(this scoped Span<T> span, Func<T, TResult> selector) where TResult : IComparable<TResult> 
         => Min((ReadOnlySpan<T>)span, selector);
     
-    public static TResult Min<T, TResult>(this in ReadOnlySpan<T> span, Func<T, TResult> selector)
+    public static TResult Min<T, TResult>(this scoped ReadOnlySpan<T> span, Func<T, TResult> selector)
         where TResult : IComparable<TResult> {
         if (span.Length == 0) throw new InvalidOperationException("Sequence contains no elements");
 
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQSelectExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQSelectExtensions.cs
@@ -8,39 +8,47 @@ namespace CodeOfChaos.SpanLINQ;
 // ---------------------------------------------------------------------------------------------------------------------
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQSelectExtensions {
-    public static void Select<TSource, TResult>(this in Span<TSource> source, Func<TSource, TResult> selector, Span<TResult> destination)
-        => Select((ReadOnlySpan<TSource>)source, selector, destination);
-    
+    public static void Select<TSource, TResult>(
+        this scoped Span<TSource> source,
+        Func<TSource, TResult> selector,
+        scoped Span<TResult> destination
+    ) => Select((ReadOnlySpan<TSource>)source, selector, destination);
+
     public static void Select<TSource, TResult>(
         this in ReadOnlySpan<TSource> source,
         Func<TSource, TResult> selector,
-        Span<TResult> destination
+        scoped Span<TResult> destination
     ) {
         if (source.Length > destination.Length) throw new ArgumentException("Destination span is too small");
 
         for (int i = 0; i < source.Length; i++) {
             destination[i] = selector(source[i]);
         }
     }
-    
-    public static void SelectMany<TSource, TResult>(this in Span<TSource> source, Func<TSource, ReadOnlySpan<TResult>> selector, Span<TResult> destination, out int totalCount) 
-        => SelectMany((ReadOnlySpan<TSource>)source, selector, destination, out totalCount);
+
+    public static void SelectMany<TSource, TResult>(
+        this scoped Span<TSource> source,
+        Func<TSource, ReadOnlySpan<TResult>> selector,
+        scoped Span<TResult> destination,
+        out int totalCount
+    ) => SelectMany((ReadOnlySpan<TSource>)source, selector, destination, out totalCount);
 
     public static void SelectMany<TSource, TResult>(
         this in ReadOnlySpan<TSource> source,
         Func<TSource, ReadOnlySpan<TResult>> selector,
-        Span<TResult> destination,
+        scoped Span<TResult> destination,
         out int totalCount
     ) {
         if (source.Length > destination.Length) throw new ArgumentException("Destination span is too small");
 
         int destinationMaxCount = destination.Length;
         totalCount = 0;
-        
+
         // ReSharper disable once ForCanBeConvertedToForeach
         for (int i = 0; i < source.Length; i++) {
             ReadOnlySpan<TResult> nested = selector(source[i]);
             if (totalCount + nested.Length > destinationMaxCount) throw new ArgumentException("Destination span is too small");
+
             nested.CopyTo(destination[totalCount..]);
             totalCount += nested.Length;
         }
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQSumExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQSumExtensions.cs
@@ -9,13 +9,13 @@ namespace CodeOfChaos.SpanLINQ;
 // ---------------------------------------------------------------------------------------------------------------------
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQSumExtensions {
-    public static int Sum<T>(this in Span<T> span, Func<T, int> selector, int length = -1) 
+    public static int Sum<T>(this scoped Span<T> span, Func<T, int> selector, int length = -1) 
         => Sum((ReadOnlySpan<T>)span, selector, length);
     
-    public static int Sum<T>(this in Span<T> span, Func<T, int> selector, Range range) 
+    public static int Sum<T>(this scoped Span<T> span, Func<T, int> selector, Range range) 
         => Sum((ReadOnlySpan<T>)span, selector, range);
     
-    public static int Sum<T>(this in ReadOnlySpan<T> span, Func<T, int> selector, int length = -1) {
+    public static int Sum<T>(this scoped ReadOnlySpan<T> span, Func<T, int> selector, int length = -1) {
         int totalGroups = 0;
         length = length switch {
             < -1 => throw new ArgumentOutOfRangeException(nameof(length)),
@@ -29,7 +29,7 @@ public static int Sum<T>(this in ReadOnlySpan<T> span, Func<T, int> selector, in
         return totalGroups;
     }
     
-    public static int Sum<T>(this in ReadOnlySpan<T> span, Func<T, int> selector, Range range) {
+    public static int Sum<T>(this scoped ReadOnlySpan<T> span, Func<T, int> selector, Range range) {
         int totalGroups = 0;
         ReadOnlySpan<T> slice = span[range];
         int length = slice.Length;
diff --git a/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQWhereExtensions.cs b/src/CodeOfChaos.Extensions/SpanLINQ/SpanLINQWhereExtensions.cs
@@ -8,15 +8,30 @@ namespace CodeOfChaos.SpanLINQ;
 // ---------------------------------------------------------------------------------------------------------------------
 // ReSharper disable once InconsistentNaming
 public static class SpanLINQWhereExtensions {
-    public static void Where<T>(this in Span<T> span, Func<T, bool> predicate, in Span<int> indices, out int count) 
+    public static void Where<T>(this scoped Span<T> span, Func<T, bool> predicate, scoped Span<int> indices, out int count) 
         => Where((ReadOnlySpan<T>)span, predicate, indices, out count);
     
-    public static void Where<T>(this in ReadOnlySpan<T> span, Func<T, bool> predicate, in Span<int> indices, out int count) {
+    public static void Where<T>(this scoped ReadOnlySpan<T> span, Func<T, bool> predicate, scoped Span<int> indices, out int count) {
         if (indices.Length < span.Length) throw new ArgumentException("Indices span is too small");
         
         count = 0;
-        for (int i = 0; i < span.Length && count < indices.Length; i++) {
+        for (int i = 0; i < span.Length; i++) {
             if (predicate(span[i])) indices[count++] = i;
         }
     }
+    
+    public static int Where<T>(this scoped Span<T> span, Func<T, bool> predicate, scoped Span<T> destination) 
+        => Where((ReadOnlySpan<T>)span, predicate, destination);
+    
+    public static int Where<T>(this scoped ReadOnlySpan<T> span, Func<T, bool> predicate, scoped Span<T> destination)  {
+        if (destination.Length < span.Length) throw new ArgumentException("Destination span is too small");
+        
+        int count = 0;
+        for (int i = 0; i < span.Length; i++) {
+            T item = span[i];
+            if (predicate(item)) destination[count++] = item;
+        }
+        
+        return count;
+    }
 }
diff --git a/tests/Benchmarks.CodeOfChaos.Extensions/Benchmarks.CodeOfChaos.Extensions.csproj b/tests/Benchmarks.CodeOfChaos.Extensions/Benchmarks.CodeOfChaos.Extensions.csproj
@@ -0,0 +1,14 @@
+﻿<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net9.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="BenchmarkDotNet" Version="0.15.2" />
+    </ItemGroup>
+
+</Project>
diff --git a/tests/Benchmarks.CodeOfChaos.Extensions/Program.cs b/tests/Benchmarks.CodeOfChaos.Extensions/Program.cs
@@ -0,0 +1,16 @@
+﻿// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+using BenchmarkDotNet.Running;
+using Benchmarks.CodeOfChaos.Extensions.SpanLINQ;
+
+namespace Benchmarks.CodeOfChaos.Extensions;
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+public static class Program {
+    public static void Main() {
+        BenchmarkRunner.Run<InVsScopedVsRefVsRefReadonlyBenchmarks>();
+    }
+}
diff --git a/tests/Benchmarks.CodeOfChaos.Extensions/SpanLINQ/InVsScopedBenchmarks.cs b/tests/Benchmarks.CodeOfChaos.Extensions/SpanLINQ/InVsScopedBenchmarks.cs
@@ -0,0 +1,107 @@
+﻿// ---------------------------------------------------------------------------------------------------------------------
+// Imports
+// ---------------------------------------------------------------------------------------------------------------------
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Order;
+using System.Runtime.CompilerServices;
+
+namespace Benchmarks.CodeOfChaos.Extensions.SpanLINQ;
+// ---------------------------------------------------------------------------------------------------------------------
+// Code
+// ---------------------------------------------------------------------------------------------------------------------
+[MemoryDiagnoser]
+[Orderer(SummaryOrderPolicy.Declared)]
+public class InVsScopedVsRefVsRefReadonlyBenchmarks {
+    // Parameter for data sizes
+    [Params(10, 1000, 100000)]
+    public int DataSize { get; set; }
+
+    // Parameter for match scenarios
+    [ParamsSource(nameof(MatchScenarios))]
+    public MatchScenario Scenario { get; set; }
+
+    private int[] _data;
+
+    [GlobalSetup]
+    public void Setup() {
+        _data = Enumerable.Range(1, DataSize).ToArray();
+    }
+
+    public static IEnumerable<MatchScenario> MatchScenarios => new[] {
+        new MatchScenario("NoMatch", x => x < 0),
+        new MatchScenario("MiddleMatch", x => x == 500),
+        new MatchScenario("ImmediateMatch", x => x > 0)
+    };
+
+    public record MatchScenario(string Name, Func<int, bool> Predicate) {
+        public override string ToString() => Name;
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    // Methods
+    // -----------------------------------------------------------------------------------------------------------------
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static bool AnyScoped<T>(scoped ReadOnlySpan<T> span, Func<T, bool> predicate) {
+        for (int i = span.Length - 1; i >= 0; i--)
+            if (predicate(span[i]))
+                return true;
+
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static bool AnyIn<T>(in ReadOnlySpan<T> span, Func<T, bool> predicate) {
+        for (int i = span.Length - 1; i >= 0; i--)
+            if (predicate(span[i]))
+                return true;
+
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static bool AnyRef<T>(ref ReadOnlySpan<T> span, Func<T, bool> predicate) {
+        for (int i = span.Length - 1; i >= 0; i--)
+            if (predicate(span[i]))
+                return true;
+
+        return false;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static bool AnyRefReadonly<T>(ref readonly ReadOnlySpan<T> span, Func<T, bool> predicate) {
+        for (int i = span.Length - 1; i >= 0; i--)
+            if (predicate(span[i]))
+                return true;
+
+        return false;
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    // Methods
+    // -----------------------------------------------------------------------------------------------------------------
+    
+    [Benchmark]
+    public bool Bench_Scoped() {
+        ReadOnlySpan<int> span = _data;
+        return AnyScoped(span, Scenario.Predicate);
+    }
+
+    [Benchmark]
+    public bool Bench_In() {
+        ReadOnlySpan<int> span = _data;
+        return AnyIn(span, Scenario.Predicate);
+    }
+
+    [Benchmark]
+    public bool Bench_Ref() {
+        ReadOnlySpan<int> span = _data;
+        return AnyRef(ref span, Scenario.Predicate);
+    }
+
+    [Benchmark]
+    public bool Bench_RefReadOnly() {
+        ReadOnlySpan<int> span = _data;
+        return AnyRefReadonly(ref span, Scenario.Predicate);
+    }
+}
