Update AddValuesToArray sample: net10.0, append methods, grow benchmark

collections-arrays/AddValuesToArray/AddValuesToArray.Benchmark/AddValuesToArray.Benchmark.csproj

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

collections-arrays/AddValuesToArray/AddValuesToArray.Benchmark/AddValuesToArrayBenchmark.cs

@@ -6,49 +6,37 @@ namespace AddValuesToArray.Benchmark;
 [MemoryDiagnoser, Orderer(SummaryOrderPolicy.FastestToSlowest)]
 [GroupBenchmarksBy(BenchmarkDotNet.Configs.BenchmarkLogicalGroupRule.ByCategory)]
 [CategoriesColumn]
+[HideColumns("StdDev", "Median", "Gen0", "Gen1")]
 public class AddValuesToArrayBenchmark
 {
-    int[] concatArray = Enumerable.Range(0, 10000).ToArray();
-    int[] copyToArray = Enumerable.Range(0, 10000).ToArray();
-    List<int> list = Enumerable.Range(0, 10000).ToList();
+    private int[] _source = [];
+    private List<int> _list = [];
 
-    public IEnumerable<object> ArraySize()
+    [Params(1_000, 10_000)]
+    public int ArraySize { get; set; }
+
+    [GlobalSetup]
+    public void GlobalSetup()
     {
-        yield return 10_000;
+        _source = Enumerable.Range(0, ArraySize).ToArray();
+        _list = Enumerable.Range(0, ArraySize).ToList();
     }
 
     [Benchmark, BenchmarkCategory("Manual")]
-    [ArgumentsSource(nameof(ArraySize))]
-    public void ArrayIndexInitializer(int arraySize)
-    {
-        AddValuesToArrayMethods.ArrayIndexInitializer(arraySize);
-    }
+    public int[] ArrayIndexInitializer() => AddValuesToArrayMethods.ArrayIndexInitializer(ArraySize);
 
     [Benchmark, BenchmarkCategory("Manual")]
-    [ArgumentsSource(nameof(ArraySize))]
-    public void SetValueMethod(int arraySize)
-    {
-        AddValuesToArrayMethods.SetValueMethod(arraySize);
-    }
+    public int[] SetValueMethod() => AddValuesToArrayMethods.SetValueMethod(ArraySize);
 
     [Benchmark, BenchmarkCategory("Populated Collection")]
-    [ArgumentsSource(nameof(ArraySize))]
-    public void ListCollection(int arraySize)
-    {
-        AddValuesToArrayMethods.UsingList(arraySize, list);
-    }
+    public int[] ListCollection() => AddValuesToArrayMethods.UsingList(_list);
 
     [Benchmark, BenchmarkCategory("Populated Collection")]
-    [ArgumentsSource(nameof(ArraySize))]
-    public void LinqConcat(int arraySize)
-    {
-        AddValuesToArrayMethods.LinqConcat(concatArray);
-    }
+    public int[] LinqConcat() => AddValuesToArrayMethods.LinqConcat(_source);
 
     [Benchmark, BenchmarkCategory("Populated Collection")]
-    [ArgumentsSource(nameof(ArraySize))]
-    public void ArrayCopyTo(int arraySize)
-    {
-        AddValuesToArrayMethods.ArrayCopyTo(arraySize, copyToArray);
-    }
+    public int[] ArrayCopyTo() => AddValuesToArrayMethods.ArrayCopyTo(ArraySize, _source);
+
+    [Benchmark, BenchmarkCategory("Populated Collection")]
+    public int[] CollectionExpression() => AddValuesToArrayMethods.CollectionExpression(_source);
 }

collections-arrays/AddValuesToArray/AddValuesToArray.Benchmark/GrowBenchmark.cs

@@ -0,0 +1,17 @@
+using BenchmarkDotNet.Attributes;
+
+namespace AddValuesToArray.Benchmark;
+
+[MemoryDiagnoser]
+[HideColumns("StdDev", "Median", "Gen0", "Gen1", "Gen2")]
+public class GrowBenchmark
+{
+    [Params(1_000, 10_000)]
+    public int Count { get; set; }
+
+    [Benchmark]
+    public int[] ResizeInALoop() => AddValuesToArrayMethods.GrowWithResize(Count);
+
+    [Benchmark]
+    public int[] ListAddThenToArray() => AddValuesToArrayMethods.GrowWithList(Count);
+}

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

@@ -6,6 +6,6 @@ internal class Program
 {
     static void Main(string[] args)
     {
-        BenchmarkRunner.Run<AddValuesToArrayBenchmark>();
+        BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
     }
 }

collections-arrays/AddValuesToArray/AddValuesToArray/AddValuesToArray.csproj

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

collections-arrays/AddValuesToArray/AddValuesToArray/AddValuesToArrayMethods.cs

@@ -25,7 +25,7 @@ public static int[] SetValueMethod(int arraySize)
         return array;
     }
 
-    public static int[] UsingList(int arraySize, List<int> list)
+    public static int[] UsingList(List<int> list)
     {
         return list.ToArray();
     }
@@ -41,10 +41,47 @@ public static int[] LinqConcat(int[] array)
 
     public static int[] ArrayCopyTo(int arraySize, int[] array)
     {
-        var array1 = new int[arraySize];       
+        var array1 = new int[arraySize];
 
         array.CopyTo(array1, 0);
 
         return array1;
     }
+
+    public static int[] AppendWithResize(int[] array, int value)
+    {
+        Array.Resize(ref array, array.Length + 1);
+        array[^1] = value;
+
+        return array;
+    }
+
+    public static int[] AppendWithCollectionExpression(int[] array, int value) => [.. array, value];
+
+    public static int[] CollectionExpression(int[] array) => [.. array];
+
+    public static int[] GrowWithResize(int count)
+    {
+        var array = Array.Empty<int>();
+
+        for (var index = 0; index < count; index++)
+        {
+            Array.Resize(ref array, array.Length + 1);
+            array[index] = index;
+        }
+
+        return array;
+    }
+
+    public static int[] GrowWithList(int count)
+    {
+        var list = new List<int>();
+
+        for (var index = 0; index < count; index++)
+        {
+            list.Add(index);
+        }
+
+        return list.ToArray();
+    }
 }

collections-arrays/AddValuesToArray/AddValuesToArray/Program.cs

@@ -14,7 +14,7 @@ static void Main(string[] args)
 
         Console.WriteLine(nameof(AddValuesToArrayMethods.UsingList));
         var list = Enumerable.Range(0, 5).ToList();
-        var array3 = AddValuesToArrayMethods.UsingList(5, list);
+        var array3 = AddValuesToArrayMethods.UsingList(list);
         Console.WriteLine(string.Join(", ", array3));
 
         Console.WriteLine(nameof(AddValuesToArrayMethods.LinqConcat));

collections-arrays/AddValuesToArray/Tests/AddValuesToArrayUnitTest.cs

@@ -27,7 +27,7 @@ public void GivenAnArraySize_WhenUsingSetValueMethod_ThenValuesShouldBeAdded()
     public void GivenAnArraySize_WhenUsingLinqList_ThenValuesShouldBeAdded()
     {
         var list = Enumerable.Range(0, 3).ToList();
-        var array = AddValuesToArrayMethods.UsingList(3, list);
+        var array = AddValuesToArrayMethods.UsingList(list);
 
         Assert.Equal(0, array[0]);
         Assert.Equal(1, array[1]);
@@ -55,4 +55,59 @@ public void GivenAnArraySize_WhenUsingArrayCopyTo_ThenValuesShouldBeAdded()
         Assert.Equal(1, array[1]);
         Assert.Equal(2, array[2]);
     }
-}
+
+    [Fact]
+    public void GivenAnArray_WhenAppendingWithResize_ThenTheOriginalArrayIsUnchanged()
+    {
+        var original = new[] { 100, 101, 102 };
+        var alias = original;
+
+        var appended = AddValuesToArrayMethods.AppendWithResize(original, 103);
+
+        Assert.Equal(4, appended.Length);
+        Assert.Equal(3, alias.Length);
+        Assert.False(ReferenceEquals(appended, alias));
+    }
+
+    [Fact]
+    public void GivenAnArray_WhenAppendingWithResize_ThenTheValueIsAddedAtTheEnd()
+    {
+        var array = new[] { 100, 101, 102 };
+
+        var appended = AddValuesToArrayMethods.AppendWithResize(array, 103);
+
+        Assert.Equal(new[] { 100, 101, 102, 103 }, appended);
+    }
+
+    [Fact]
+    public void GivenAnArray_WhenAppendingWithCollectionExpression_ThenANewArrayIsReturned()
+    {
+        var array = new[] { 100, 101, 102 };
+
+        var appended = AddValuesToArrayMethods.AppendWithCollectionExpression(array, 103);
+
+        Assert.Equal(new[] { 100, 101, 102, 103 }, appended);
+        Assert.False(ReferenceEquals(array, appended));
+    }
+
+    [Fact]
+    public void GivenAnArray_WhenUsingCollectionExpression_ThenACopyIsReturned()
+    {
+        var array = Enumerable.Range(0, 3).ToArray();
+
+        var copy = AddValuesToArrayMethods.CollectionExpression(array);
+
+        Assert.Equal(array, copy);
+        Assert.False(ReferenceEquals(array, copy));
+    }
+
+    [Fact]
+    public void GivenACount_WhenGrowingWithResizeAndWithList_ThenBothProduceTheSameArray()
+    {
+        var resized = AddValuesToArrayMethods.GrowWithResize(5);
+        var listed = AddValuesToArrayMethods.GrowWithList(5);
+
+        Assert.Equal(new[] { 0, 1, 2, 3, 4 }, resized);
+        Assert.Equal(resized, listed);
+    }
+}

collections-arrays/AddValuesToArray/Tests/Tests.csproj

@@ -1,21 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.10.0" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="4.0.0">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="3.1.2">
+    <PackageReference Include="coverlet.collector" Version="10.0.1">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>