Remove elements from an array: net11.0 update

collections-arrays/DeleteElementsFromArray/DeleteElementsFromArray.Benchmark/DeleteElementsFromArray.Benchmark.csproj

@@ -2,13 +2,13 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net11.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.5" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.15.8" />
   </ItemGroup>
 
   <ItemGroup>

collections-arrays/DeleteElementsFromArray/DeleteElementsFromArray.Benchmark/DeleteElementsFromArrayBenchmark.cs

@@ -1,179 +1,59 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Order;
-using System.Buffers;
+using DeleteElementsFromAnArray;
 
-namespace BenchmarkRunner
-{
-
-    [MemoryDiagnoser]
-    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
-    [RankColumn]
-    public class DeleteElementsFromAnArrayBenchmark
-    {
-        private readonly int[] _myArray = FillArray();
-
-        private readonly int _key = 7;
-
-        [Benchmark]
-        public int[] DeleteWithFindAll()
-        {
-            return Array.FindAll(_myArray, i => i != _key);
-        }
-
-        [Benchmark]
-        public int[] DeleteWithRemoveAll()
-        {
-            var list = new List<int>(_myArray);
-            list.RemoveAll(e => e == _key);
-
-            return list.ToArray();
-        }
-
-        [Benchmark]
-        public int[] DeleteWithList()
-        {
-            var indexToRemove = Array.IndexOf(_myArray, _key);
-
-            if (indexToRemove < 0)
-            {
-                return _myArray;
-            }
-
-            var list = new List<int>(_myArray.Length);
-
-            for (int i = 0; i < _myArray.Length; i++)
-            {
-                if (_myArray[i] != _key)
-                {
-                    list.Add(_myArray[i]);
-                }
-            }
-
-            return list.ToArray();
-        }
-
-        [Benchmark]
-        public int[] DeleteWithWhere()
-        {
-            return _myArray.Where(e => e != _key).ToArray();
-        }
+namespace BenchmarkRunner;
 
-        [Benchmark]
-        public int[] DeleteWithArrayCopy()
-        {
-            var indexToRemove = Array.IndexOf(_myArray, _key);
-
-            if (indexToRemove < 0)
-            {
-                return _myArray;
-            }
-
-            var tempArray = new int[_myArray.Length - 1];
-
-            Array.Copy(_myArray, 0, tempArray, 0, indexToRemove);
-
-            Array.Copy(_myArray, indexToRemove + 1, tempArray, indexToRemove, _myArray.Length - indexToRemove - 1);
-
-            return tempArray;
-        }
+[InProcess]
+[MemoryDiagnoser]
+[Orderer(SummaryOrderPolicy.FastestToSlowest)]
+[RankColumn]
+public class DeleteElementsFromAnArrayBenchmark
+{
+    private readonly int[] _myArray = FillArray();
 
-        [Benchmark]
-        public int[] DeleteWithBufferCopy()
-        {
-            var indexToRemove = Array.IndexOf(_myArray, _key);
+    private readonly int _key = 7;
 
-            if (indexToRemove < 0)
-            {
-                return _myArray;
-            }
+    [Benchmark]
+    public int[] DeleteWithArrayCopy() => Methods.DeleteWithArrayCopy(_myArray, _key);
 
-            var tempArray = new int[_myArray.Length - 1];
+    [Benchmark]
+    public int[] DeleteWithBufferCopy() => Methods.DeleteWithBufferCopy(_myArray, _key);
 
-            Buffer.BlockCopy(_myArray, 0, tempArray, 0, indexToRemove * 4);
+    [Benchmark]
+    public int[] DeleteWithArraySegment() => Methods.DeleteWithArraySegment(_myArray, _key);
 
-            Buffer.BlockCopy(_myArray, (indexToRemove + 1) * 4, tempArray, indexToRemove * 4, (_myArray.Length - indexToRemove - 1) * 4);
+    [Benchmark]
+    public int[] DeleteWithLoop() => Methods.DeleteWithLoop(_myArray, _key);
 
-            return tempArray;
-        }
+    [Benchmark]
+    public int[] DeleteWithCollectionExpression() => Methods.DeleteWithCollectionExpression(_myArray, _key);
 
-        [Benchmark]
-        public int[] DeleteWithArraySegment()
-        {
-            var indexToRemove = Array.IndexOf(_myArray, _key);
+    [Benchmark]
+    public int[] DeleteWithFindAll() => Methods.DeleteWithFindAll(_myArray, _key);
 
-            if (indexToRemove < 0)
-            {
-                return _myArray;
-            }
+    [Benchmark]
+    public int[] DeleteWithWhere() => Methods.DeleteWithWhere(_myArray, _key);
 
-            int[] tempArray;
+    [Benchmark]
+    public int[] DeleteWithRemoveAll() => Methods.DeleteWithRemoveAll(_myArray, _key);
 
-            var segment1 = new ArraySegment<int>(_myArray, 0, indexToRemove);
+    [Benchmark]
+    public int[] DeleteWithList() => Methods.DeleteWithList(_myArray, _key);
 
-            var segment2 = new ArraySegment<int>(_myArray, indexToRemove + 1, _myArray.Length - indexToRemove - 1);
+    [Benchmark]
+    public int[] DeleteWithPooledArray() => Methods.DeleteWithPooledArray(_myArray, _key);
 
-            tempArray = segment1.Concat(segment2).ToArray();
-
-            return tempArray;
-        }
-
-        [Benchmark]
-        public int[] DeleteWithLoop()
-        {
-            var indexToRemove = Array.IndexOf(_myArray, _key);
-
-            if (indexToRemove < 0)
-            {
-                return _myArray;
-            }
-
-            var tempArray = new int[_myArray.Length - 1];
-
-            for (int i = 0, j = 0; i < _myArray.Length; i++)
-            {
-                if (i == indexToRemove)
-                {
-                    continue;
-                }
-                tempArray[j] = _myArray[i];
-                j++;
-            }
-
-            return tempArray;
-        }
+    private static int[] FillArray()
+    {
+        var rnd = new Random(42);
+        var myArray = new int[1000];
 
-        [Benchmark]
-        public int[] DeleteWithPooledArray()
+        for (int i = 0; i < 1000; i++)
         {
-            var tempArray = ArrayPool<int>.Shared.Rent(_myArray.Length);
-            try
-            {
-                var tempSpan = tempArray.AsSpan();
-                var index = 0;
-                foreach (var element in _myArray.AsSpan())
-                {
-                    if (element != _key) tempSpan[index++] = element;
-                }
-
-                return tempSpan[0..index].ToArray();
-            }
-            finally
-            {
-                ArrayPool<int>.Shared.Return(tempArray);
-            }
+            myArray[i] = rnd.Next(1, 10);
         }
 
-        private static int[] FillArray()
-        {
-            var rnd = new Random();
-            var myArray = new int[1000];
-
-            for (int i = 0; i < 1000; i++)
-            {
-                myArray[i] = rnd.Next(1, 10);
-            }
-
-            return myArray;
-        }
+        return myArray;
     }
-}
+}

collections-arrays/DeleteElementsFromArray/DeleteElementsFromArray.Benchmark/Program.cs

@@ -1,3 +1,4 @@
-using BenchmarkRunner;
+using BenchmarkDotNet.Running;
+using BenchmarkRunner;
 
-BenchmarkDotNet.Running.BenchmarkRunner.Run<DeleteElementsFromAnArrayBenchmark>();
+BenchmarkSwitcher.FromAssembly(typeof(DeleteElementsFromAnArrayBenchmark).Assembly).Run(args);

collections-arrays/DeleteElementsFromArray/DeleteElementsFromArray/DeleteElementsFromArray.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net11.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>

collections-arrays/DeleteElementsFromArray/DeleteElementsFromArray/Methods/DeleteWithArrayCopy.cs

@@ -1,23 +1,21 @@
-namespace DeleteElementsFromAnArray 
+namespace DeleteElementsFromAnArray;
+
+public static partial class Methods
 {
-    public static partial class Methods 
+    public static int[] DeleteWithArrayCopy(int[] inputArray, int elementToRemove)
     {
-        public static int[] DeleteWithArrayCopy(int[] inputArray, int elementToRemove) 
-        {
-            var indexToRemove = Array.IndexOf(inputArray, elementToRemove);
-
-            if(indexToRemove < 0) 
-            {
-                return inputArray;
-            }
+        var indexToRemove = Array.IndexOf(inputArray, elementToRemove);
 
-            var newArray = new int[inputArray.Length - 1];
+        if (indexToRemove < 0)
+        {
+            return inputArray;
+        }
 
-            Array.Copy(inputArray, 0, newArray, 0, indexToRemove);
+        var tempArray = new int[inputArray.Length - 1];
 
-            Array.Copy(inputArray, indexToRemove + 1, newArray, indexToRemove, inputArray.Length - indexToRemove - 1);
+        Array.Copy(inputArray, 0, tempArray, 0, indexToRemove);
+        Array.Copy(inputArray, indexToRemove + 1, tempArray, indexToRemove, inputArray.Length - indexToRemove - 1);
 
-            return newArray;
-        }
+        return tempArray;
     }
-}
+}

collections-arrays/DeleteElementsFromArray/DeleteElementsFromArray/Methods/DeleteWithArraySegment.cs

@@ -1,25 +1,19 @@
-namespace DeleteElementsFromAnArray
+namespace DeleteElementsFromAnArray;
+
+public static partial class Methods
 {
-    public static partial class Methods
+    public static int[] DeleteWithArraySegment(int[] inputArray, int elementToRemove)
     {
-        public static int[] DeleteWithArraySegment(int[] inputArray, int elementToRemove)
-        {
-            var indexToRemove = Array.IndexOf(inputArray, elementToRemove); 
-
-            if (indexToRemove < 0)
-            {
-                return inputArray;
-            }
-
-            int[] tempArray; 
-
-            var segment1 = new ArraySegment<int>(inputArray, 0, indexToRemove);
+        var indexToRemove = Array.IndexOf(inputArray, elementToRemove);
 
-            var segment2 = new ArraySegment<int>(inputArray, indexToRemove + 1, inputArray.Length - indexToRemove - 1);
+        if (indexToRemove < 0)
+        {
+            return inputArray;
+        }
 
-            tempArray = segment1.Concat(segment2).ToArray();
+        var segment1 = new ArraySegment<int>(inputArray, 0, indexToRemove);
+        var segment2 = new ArraySegment<int>(inputArray, indexToRemove + 1, inputArray.Length - indexToRemove - 1);
 
-            return tempArray;
-        }
+        return segment1.Concat(segment2).ToArray();
     }
-}
+}

collections-arrays/DeleteElementsFromArray/DeleteElementsFromArray/Methods/DeleteWithBufferCopy.cs

@@ -1,23 +1,26 @@
-namespace DeleteElementsFromAnArray
+namespace DeleteElementsFromAnArray;
+
+public static partial class Methods
 {
-    public static partial class Methods
+    public static int[] DeleteWithBufferCopy(int[] inputArray, int elementToRemove)
     {
-        public static int[] DeleteWithBufferCopy(int[] inputArray, int elementToRemove)
-        {
-            var indexToRemove = Array.IndexOf(inputArray, elementToRemove);
+        var indexToRemove = Array.IndexOf(inputArray, elementToRemove);
 
-            if (indexToRemove < 0)
-            {
-                return inputArray;
-            }
+        if (indexToRemove < 0)
+        {
+            return inputArray;
+        }
 
-            var tempArray = new int[inputArray.Length - 1];
+        var tempArray = new int[inputArray.Length - 1];
 
-            Buffer.BlockCopy(inputArray, 0, tempArray, 0, indexToRemove * 4);
+        Buffer.BlockCopy(inputArray, 0, tempArray, 0, indexToRemove * sizeof(int));
 
-            Buffer.BlockCopy(inputArray, (indexToRemove + 1) * 4, tempArray, indexToRemove * 4, (inputArray.Length - indexToRemove - 1) * 4);
+        Buffer.BlockCopy(inputArray,
+            (indexToRemove + 1) * sizeof(int),
+            tempArray,
+            indexToRemove * sizeof(int),
+            (inputArray.Length - indexToRemove - 1) * sizeof(int));
 
-            return tempArray;
-        }
+        return tempArray;
     }
 }

collections-arrays/DeleteElementsFromArray/DeleteElementsFromArray/Methods/DeleteWithCollectionExpression.cs

@@ -0,0 +1,23 @@
+namespace DeleteElementsFromAnArray;
+
+public static partial class Methods
+{
+    public static int[] DeleteWithCollectionExpression(int[] inputArray, int elementToRemove)
+    {
+        var indexToRemove = Array.IndexOf(inputArray, elementToRemove);
+
+        if (indexToRemove < 0)
+        {
+            return inputArray;
+        }
+
+        var span = inputArray.AsSpan();
+
+        return [.. span[..indexToRemove], .. span[(indexToRemove + 1)..]];
+    }
+
+    public static int[] DeleteFirstElement(int[] inputArray)
+    {
+        return inputArray[1..];
+    }
+}