ObjectComparison: .NET 10, null-safe comparers, copy-per-call benchmark

csharp-intermediate-topics/ObjectComparison/ObjectComparison/Employee.cs

@@ -1,55 +1,58 @@
-namespace ObjectComparisons
+namespace ObjectComparisons;
+
+public partial class Employee : IComparable<Employee>
 {
-    public partial class Employee : IComparable<Employee>
+    public int Id { get; set; }
+    public string? Name { get; set; }
+
+    public Employee(int id, string? name)
     {
-        public int Id { get; set; }
-        public string? Name { get; set; }
+        Id = id;
+        Name = name;
+    }
 
-        public Employee(int id, string? name)
-        {
-            Id = id;
-            Name = name;
-        }
+    public int CompareTo(Employee? otherEmployee)
+    {
+        return otherEmployee is null ? 1 : Id.CompareTo(otherEmployee.Id);
+    }
 
-        public int CompareTo(Employee? otherEmployee)
-        {
-            return otherEmployee is null ? 1 : Id.CompareTo(otherEmployee.Id);
-        }
+    public static IComparer<Employee> SortByIdAscending()
+    {
+        return new SortByIdAscendingHelper();
+    }
 
-        public static IComparer<Employee> SortByIdAscending()
-        {
-            return new SortByIdAscendingHelper();
-        }
+    public static IComparer<Employee> SortByIdDescending()
+    {
+        return new SortByIdDescendingHelper();
+    }
 
-        public static IComparer<Employee> SortByIdDescending()
+    public static int CompareEmployeesByIdAscending(Employee? employee1, Employee? employee2)
+    {
+        if (employee1 is null)
         {
-            return new SortByIdDescendingHelper();
+            return employee2 is null ? 0 : -1;
         }
 
-        public static int CompareEmployeesByIdAscending(Employee employee1, Employee employee2)
+        if (employee2 is null)
         {
-            if ((employee1 is null) || (employee2 is null))
-            {
-                return 0;
-            }
+            return 1;
+        }
 
-            int value1 = employee1?.Id ?? 0;
-            int value2 = employee2?.Id ?? 0;
+        return employee1.Id.CompareTo(employee2.Id);
+    }
 
-            return value1.CompareTo(value2);
+    public static int CompareEmployeesByIdDescending(Employee? employee1, Employee? employee2)
+    {
+        if (employee1 is null)
+        {
+            return employee2 is null ? 0 : -1;
         }
 
-        public static int CompareEmployeesByIdDescending(Employee employee1, Employee employee2)
+        if (employee2 is null)
         {
-            if ((employee1 is null) || (employee2 is null))
-            {
-                return 0;
-            }
-
-            int value1 = employee1?.Id ?? 0;
-            int value2 = employee2?.Id ?? 0;
-
-            return value2.CompareTo(value1);
+            return 1;
         }
+
+        return employee2.Id.CompareTo(employee1.Id);
     }
 }

csharp-intermediate-topics/ObjectComparison/ObjectComparison/ObjectComparisonBenchmark.cs

@@ -2,50 +2,53 @@
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Order;
 
-namespace ObjectComparisons
+namespace ObjectComparisons;
+
+[MemoryDiagnoser]
+[Orderer(SummaryOrderPolicy.FastestToSlowest)]
+[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByParams)]
+public class ObjectComparisonBenchmark
 {
-    [MemoryDiagnoser]
-    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
-    [GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByParams)]
-    public class ObjectComparisonBenchmark
+    private Employee[] _source = [];
+    private Employee[] _employees = [];
+
+    [Params(5, 1_000)]
+    public int Size { get; set; }
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        var ids = Enumerable.Range(1, Size).ToArray();
+        new Random(42).Shuffle(ids);
+
+        _source = ids.Select(id => new Employee(id, $"Employee {id}")).ToArray();
+        _employees = new Employee[Size];
+    }
+
+    [Benchmark]
+    public Employee[] CompareUsingIComparable()
+    {
+        _source.CopyTo(_employees, 0);
+        Array.Sort(_employees);
+
+        return _employees;
+    }
+
+    [Benchmark]
+    public Employee[] CompareUsingIComparer()
+    {
+        _source.CopyTo(_employees, 0);
+        Array.Sort(_employees, Employee.SortByIdAscending());
+
+        return _employees;
+    }
+
+    [Benchmark]
+    public Employee[] CompareUsingComparisonDelegate()
     {
-        [Params(10000)]
-        public int Count { get; set; }
-
-        public Employee[] Employees { get; } = new Employee[5]
-        {
-            new Employee(4, "John"),
-            new Employee(2, "Tom"),
-            new Employee(1, "Eric"),
-            new Employee(5, "Dan"),
-            new Employee(3, "Alen")
-        };
-
-        [Benchmark]
-        public void CompareUsingIComparable()
-        {
-            for (int i = 0; i < Count; i++)
-            {
-                Array.Sort(Employees);
-            }
-        }
-
-        [Benchmark]
-        public void CompareUsingIComparer()
-        {
-            for (int i = 0; i < Count; i++)
-            {
-                Array.Sort(Employees, Employee.SortByIdAscending());
-            }
-        }
-
-        [Benchmark]
-        public void CompareUsingComparisonDelegate()
-        {
-            for (int i = 0; i < Count; i++)
-            {
-                Array.Sort(Employees, Employee.CompareEmployeesByIdAscending);
-            }
-        }
+        _source.CopyTo(_employees, 0);
+        Array.Sort(_employees, Employee.CompareEmployeesByIdAscending);
+
+        return _employees;
     }
 }

csharp-intermediate-topics/ObjectComparison/ObjectComparison/ObjectComparisons.csproj

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

csharp-intermediate-topics/ObjectComparison/ObjectComparison/Program.cs

@@ -53,7 +53,13 @@
 
 PrintEmployeeList(employeeList);
 
-BenchmarkRunner.Run<ObjectComparisonBenchmark>();
+employeeList.Sort((x, y) => string.Compare(x.Name, y.Name, StringComparison.Ordinal));
+
+Console.WriteLine($"{Environment.NewLine}Sorting by Name using a Lambda Expression");
+
+PrintEmployeeList(employeeList);
+
+BenchmarkRunner.Run<ObjectComparisonBenchmark>(args: args);
 
 static void PrintEmployees(Employee[] employees)
 {
@@ -69,4 +75,4 @@ static void PrintEmployeeList(List<Employee> employees)
     {
         Console.WriteLine(employee.Id + "\t\t" + employee.Name);
     }
-}
+}

csharp-intermediate-topics/ObjectComparison/ObjectComparison/SortByIdAscendingHelper.cs

@@ -1,12 +1,19 @@
-namespace ObjectComparisons
+namespace ObjectComparisons;
+
+public class SortByIdAscendingHelper : IComparer<Employee>
 {
-    public class SortByIdAscendingHelper : IComparer<Employee>
+    public int Compare(Employee? firstEmployee, Employee? secondEmployee)
     {
-        public int Compare(Employee? firstEmployee, Employee? secondEmployee)
+        if (firstEmployee is null)
         {
-            return ((firstEmployee is null) || (secondEmployee is null)) ?
-                0 :
-                firstEmployee.Id.CompareTo(secondEmployee.Id);
+            return secondEmployee is null ? 0 : -1;
         }
+
+        if (secondEmployee is null)
+        {
+            return 1;
+        }
+
+        return firstEmployee.Id.CompareTo(secondEmployee.Id);
     }
 }

csharp-intermediate-topics/ObjectComparison/ObjectComparison/SortByIdDescendingHelper.cs

@@ -1,12 +1,19 @@
-namespace ObjectComparisons
+namespace ObjectComparisons;
+
+public class SortByIdDescendingHelper : IComparer<Employee>
 {
-    public class SortByIdDescendingHelper : IComparer<Employee>
+    public int Compare(Employee? firstEmployee, Employee? secondEmployee)
     {
-        public int Compare(Employee? firstEmployee, Employee? secondEmployee)
+        if (firstEmployee is null)
         {
-            return ((firstEmployee is null) || (secondEmployee is null)) ?
-                0 :
-                secondEmployee.Id.CompareTo(firstEmployee.Id);
+            return secondEmployee is null ? 0 : -1;
         }
+
+        if (secondEmployee is null)
+        {
+            return 1;
+        }
+
+        return secondEmployee.Id.CompareTo(firstEmployee.Id);
     }
 }