Avoid unnecessary lazy init in StructuralComparisons

The only benefit of having these be lazy in this manner is avoiding one of the two objects being constructed. We can instead just combine them into a singleton that's initialized in a static readonly.

Author: stephentoub

src/libraries/System.Collections/src/System/Collections/StructuralComparisons.cs

@@ -7,70 +7,66 @@ namespace System.Collections
 {
     public static class StructuralComparisons
     {
-        private static volatile IComparer? s_StructuralComparer;
-        private static volatile IEqualityComparer? s_StructuralEqualityComparer;
+        private static readonly Comparer s_comparer = new();
 
-        public static IComparer StructuralComparer => s_StructuralComparer ??= new StructuralComparer();
+        public static IComparer StructuralComparer => s_comparer;
 
-        public static IEqualityComparer StructuralEqualityComparer => s_StructuralEqualityComparer ??= new StructuralEqualityComparer();
-    }
+        public static IEqualityComparer StructuralEqualityComparer => s_comparer;
 
-    internal sealed class StructuralEqualityComparer : IEqualityComparer
-    {
-        public new bool Equals(object? x, object? y)
+        private sealed class Comparer : IEqualityComparer, IComparer
         {
-            if (x != null)
+            public new bool Equals(object? x, object? y)
             {
-                IStructuralEquatable? seObj = x as IStructuralEquatable;
-
-                if (seObj != null)
+                if (x != null)
                 {
-                    return seObj.Equals(y, this);
-                }
+                    IStructuralEquatable? seObj = x as IStructuralEquatable;
 
-                if (y != null)
-                {
-                    return x.Equals(y);
-                }
-                else
-                {
-                    return false;
+                    if (seObj != null)
+                    {
+                        return seObj.Equals(y, this);
+                    }
+
+                    if (y != null)
+                    {
+                        return x.Equals(y);
+                    }
+                    else
+                    {
+                        return false;
+                    }
                 }
+                if (y != null) return false;
+                return true;
             }
-            if (y != null) return false;
-            return true;
-        }
 
-        public int GetHashCode(object obj)
-        {
-            if (obj == null) return 0;
+            public int GetHashCode(object obj)
+            {
+                if (obj == null) return 0;
 
-            IStructuralEquatable? seObj = obj as IStructuralEquatable;
+                IStructuralEquatable? seObj = obj as IStructuralEquatable;
 
-            if (seObj != null)
-            {
-                return seObj.GetHashCode(this);
+                if (seObj != null)
+                {
+                    return seObj.GetHashCode(this);
+                }
+
+                return obj.GetHashCode();
             }
 
-            return obj.GetHashCode();
-        }
-    }
+            public int Compare(object? x, object? y)
+            {
+                if (x == null) return y == null ? 0 : -1;
+                if (y == null) return 1;
 
-    internal sealed class StructuralComparer : IComparer
-    {
-        public int Compare(object? x, object? y)
-        {
-            if (x == null) return y == null ? 0 : -1;
-            if (y == null) return 1;
+                IStructuralComparable? scX = x as IStructuralComparable;
 
-            IStructuralComparable? scX = x as IStructuralComparable;
+                if (scX != null)
+                {
+                    return scX.CompareTo(y, this);
+                }
 
-            if (scX != null)
-            {
-                return scX.CompareTo(y, this);
+                return Comparer<object>.Default.Compare(x, y);
             }
-
-            return Comparer<object>.Default.Compare(x, y);
         }
     }
 }