Merge pull request #95 from feO2x/dev

v10.3.0

Author: feO2x

Code/Light.GuardClauses.Performance/CollectionAssertions/CountBenchmark.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using Light.GuardClauses.FrameworkExtensions;
+
+namespace Light.GuardClauses.Performance.CollectionAssertions;
+
+public class ListCountBenchmark
+{
+    public List<int> List;
+    
+    // ReSharper disable once UnusedAutoPropertyAccessor.Global
+    [Params(100, 1000)]
+    public int NumberOfItems { get; set; }
+
+    [GlobalSetup]
+    public void Setup() => List = Enumerable.Range(1, NumberOfItems).ToList();
+
+    // ReSharper disable once UseCollectionCountProperty
+    [Benchmark(Baseline = true)]
+    public int LinqCount() => List.Count();
+
+    [Benchmark]
+    public int ExistingEnumerableCount() => EnumerableExtensions.Count(List);
+
+    [Benchmark]
+    public int NewEnumerableOfTGetCount() => List.GetCount();
+}
+
+public class StringCountBenchmark
+{
+    public string String;
+    
+    // ReSharper disable once UnusedAutoPropertyAccessor.Global
+    [Params(100, 1000)]
+    public int NumberOfItems { get; set; }
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        var random = new Random(42);
+        var array = new char[NumberOfItems];
+        for (var i = 0; i < array.Length; i++)
+        {
+            array[i] = (char) random.Next('a', 'z' + 1);
+        }
+
+        String = new (array);
+    }
+
+    // ReSharper disable once UseCollectionCountProperty
+    [Benchmark(Baseline = true)]
+    public int LinqCount() => String.Count();
+
+    [Benchmark]
+    public int ExistingEnumerableCount() => EnumerableExtensions.Count(String);
+
+    [Benchmark]
+    public int NewEnumerableOfTGetCount() => String.GetCount();
+}
+
+public class MyImmutableArrayCountBenchmark
+{
+    public MyImmutableArray<int> MyArray;
+    
+    // ReSharper disable once UnusedAutoPropertyAccessor.Global
+    [Params(100, 1000)]
+    public int NumberOfItems { get; set; }
+    
+    [GlobalSetup]
+    public void Setup() => MyArray = new (Enumerable.Range(1, NumberOfItems).ToArray());
+    
+    // ReSharper disable once UseCollectionCountProperty
+    [Benchmark(Baseline = true)]
+    public int LinqCount() => MyArray.Count();
+
+    [Benchmark]
+    public int ExistingEnumerableCount() => EnumerableExtensions.Count(MyArray);
+
+    [Benchmark]
+    public int NewEnumerableOfTGetCount() => MyArray.GetCount();
+}
+
+public sealed class MyImmutableArray<T> : IReadOnlyList<T>
+{
+    private readonly T[] _array;
+    
+    public MyImmutableArray(T[] array) => _array = array;
+
+    public IEnumerator<T> GetEnumerator() => ((IEnumerable<T>) _array).GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator() => _array.GetEnumerator();
+
+    public int Count => _array.Length;
+
+    public T this[int index] => _array[index];
+}

Code/Light.GuardClauses.Performance/Light.GuardClauses.Performance.csproj

@@ -3,11 +3,12 @@
     <PropertyGroup>
         <OutputType>Exe</OutputType>
         <TargetFrameworks>net7.0;net48</TargetFrameworks>
+        <LangVersion>11</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
         <ProjectReference Include="..\Light.GuardClauses\Light.GuardClauses.csproj" />
-        <PackageReference Include="BenchmarkDotNet" Version="0.13.7" />
+        <PackageReference Include="BenchmarkDotNet" Version="0.13.9" />
     </ItemGroup>
 
 </Project>

Code/Light.GuardClauses.Performance/Program.cs

@@ -11,7 +11,7 @@ public static class Program
         private static IConfig DefaultConfiguration =>
             DefaultConfig
                .Instance
-               .AddJob(Job.Default.WithRuntime(CoreRuntime.Core60))
+               .AddJob(Job.Default.WithRuntime(CoreRuntime.Core70))
                .AddJob(Job.Default.WithRuntime(ClrRuntime.Net48))
                .AddDiagnoser(MemoryDiagnoser.Default, new DisassemblyDiagnoser(new DisassemblyDiagnoserConfig()));
 

Code/Light.GuardClauses.Tests/CollectionAssertions/MustBeOneOfTests.cs

@@ -69,6 +69,6 @@ public static void CallerArgumentExpression()
         Action act = () => myNumber.MustBeOneOf(Enumerable.Range(1, 10));
 
         act.Should().Throw<ValueIsNotOneOfException>()
-           .And.ParamName.Should().Be(nameof(myNumber));
+           .WithParameterName(nameof(myNumber));
     }
 }

Code/Light.GuardClauses.Tests/CollectionAssertions/MustContainTests.cs

@@ -67,6 +67,6 @@ public static void CallerArgumentExpression()
         var act = () => array.MustContain("Baz");
 
         act.Should().Throw<MissingItemException>()
-           .And.ParamName.Should().Be(nameof(array));
+           .WithParameterName(nameof(array));
     }
 }

Code/Light.GuardClauses.Tests/CollectionAssertions/MustHaveCountTests.cs

@@ -68,6 +68,6 @@ public static void CallerArgumentExpression()
         Action act = () => collection.MustHaveCount(5);
 
         act.Should().Throw<InvalidCollectionCountException>()
-           .And.ParamName.Should().Be(nameof(collection));
+           .WithParameterName(nameof(collection));
     }
 }

Code/Light.GuardClauses.Tests/CollectionAssertions/MustHaveMaximumCountTests.cs

@@ -69,6 +69,6 @@ public static void CallerArgumentExpression()
         var act = () => myCollection.MustHaveMaximumCount(2);
 
         act.Should().Throw<InvalidCollectionCountException>()
-           .And.ParamName.Should().Be(nameof(myCollection));
+           .WithParameterName(nameof(myCollection));
     }
 }

Code/Light.GuardClauses.Tests/CollectionAssertions/MustHaveMinimumCountTests.cs

@@ -70,6 +70,6 @@ public static void CallerArgumentExpression()
         Action act = () => myCollection.MustHaveMinimumCount(5);
 
         act.Should().Throw<InvalidCollectionCountException>()
-           .And.ParamName.Should().Be(nameof(myCollection));
+           .WithParameterName(nameof(myCollection));
     }
 }

Code/Light.GuardClauses.Tests/CollectionAssertions/MustNotBeNullOrEmptyTests.cs

@@ -15,7 +15,7 @@ public static void CollectionNull()
         Action act = () => ((object[]) null).MustNotBeNullOrEmpty("Foo");
 
         act.Should().Throw<ArgumentNullException>()
-           .And.ParamName.Should().Be("Foo");
+           .WithParameterName("Foo");
     }
 
     [Fact]
@@ -68,7 +68,7 @@ public static void CallerArgumentExpressionForEmptyCollection()
         Action act = () => emptyArray.MustNotBeNullOrEmpty();
 
         act.Should().Throw<EmptyCollectionException>()
-           .And.ParamName.Should().Be(nameof(emptyArray));
+           .WithParameterName(nameof(emptyArray));
     }
 
     [Fact]
@@ -80,6 +80,6 @@ public static void CallerArgumentExpressionForNull()
         Action act = () => nullArray.MustNotBeNullOrEmpty();
 
         act.Should().Throw<ArgumentNullException>()
-           .And.ParamName.Should().Be(nameof(nullArray));
+           .WithParameterName(nameof(nullArray));
     }
 }

Code/Light.GuardClauses.Tests/CollectionAssertions/MustNotBeOneOfTests.cs

@@ -67,6 +67,6 @@ public static void CallerArgumentExpression()
         Action act = () => fortyTwo.MustNotBeOneOf(new[] { 42 });
 
         act.Should().Throw<ValueIsOneOfException>()
-           .And.ParamName.Should().Be(nameof(fortyTwo));
+           .WithParameterName(nameof(fortyTwo));
     }
 }