Use StringComparison instead of specialized class

src/libraries/System.Collections.Immutable/src/System.Collections.Immutable.csproj

@@ -67,10 +67,6 @@ The System.Collections.Immutable library is built-in as part of the shared frame
     <Compile Include="System\Collections\Frozen\String\OrdinalStringFrozenSet_RightJustifiedCaseInsensitiveSubstring.cs" />
     <Compile Include="System\Collections\Frozen\String\OrdinalStringFrozenSet_RightJustifiedSubstring.cs" />
     <Compile Include="System\Collections\Frozen\String\OrdinalStringFrozenSet_RightJustifiedSingleChar.cs" />
-    <Compile Include="System\Collections\Frozen\String\OrdinalStringFrozenDictionary_LeftJustifiedSingleCharCaseInsensitive.cs" />
-    <Compile Include="System\Collections\Frozen\String\OrdinalStringFrozenDictionary_LeftJustifiedSubstringCaseInsensitive.cs" />
-    <Compile Include="System\Collections\Frozen\String\OrdinalStringFrozenDictionary_RightJustifiedSingleCharCaseInsensitive.cs" />
-    <Compile Include="System\Collections\Frozen\String\OrdinalStringFrozenDictionary_RightJustifiedSubstringCaseInsensitive.cs" />
     <Compile Include="System\Collections\Frozen\String\OrdinalStringFrozenSet_LeftJustifiedSingleCharCaseInsensitive.cs" />
     <Compile Include="System\Collections\Frozen\String\OrdinalStringFrozenSet_LeftJustifiedSubstringCaseInsensitive.cs" />
     <Compile Include="System\Collections\Frozen\String\OrdinalStringFrozenSet_RightJustifiedSingleCharCaseInsensitive.cs" />

src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/FrozenDictionary.cs

@@ -192,15 +192,13 @@ private static FrozenDictionary<TKey, TValue> CreateFromDictionary<TKey, TValue>
                         {
                             if (analysis.HashCount == 1)
                             {
-                                frozenDictionary = analysis.IgnoreCase
-                                    ? new OrdinalStringFrozenDictionary_RightJustifiedSingleCharCaseInsensitive<TValue>(keys, values, stringComparer, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex)
-                                    : new OrdinalStringFrozenDictionary_RightJustifiedSingleChar<TValue>(keys, values, stringComparer, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex);
+                                var comparison = analysis.IgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+                                frozenDictionary = new OrdinalStringFrozenDictionary_RightJustifiedSingleChar<TValue>(keys, values, stringComparer, comparison, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex);
                             }
                             else
                             {
-                                frozenDictionary = analysis.IgnoreCase
-                                    ? new OrdinalStringFrozenDictionary_RightJustifiedSubstringCaseInsensitive<TValue>(keys, values, stringComparer, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex, analysis.HashCount)
-                                    : new OrdinalStringFrozenDictionary_RightJustifiedSubstring<TValue>(keys, values, stringComparer, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex, analysis.HashCount);
+                                var comparison = analysis.IgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+                                frozenDictionary = new OrdinalStringFrozenDictionary_RightJustifiedSubstring<TValue>(keys, values, stringComparer, comparison, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex, analysis.HashCount);
                             }
                         }
                     }
@@ -217,15 +215,13 @@ private static FrozenDictionary<TKey, TValue> CreateFromDictionary<TKey, TValue>
                         {
                             if (analysis.HashCount == 1)
                             {
-                                frozenDictionary = analysis.IgnoreCase
-                                    ? new OrdinalStringFrozenDictionary_LeftJustifiedSingleCharCaseInsensitive<TValue>(keys, values, stringComparer, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex)
-                                    : new OrdinalStringFrozenDictionary_LeftJustifiedSingleChar<TValue>(keys, values, stringComparer, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex);
+                                var comparison = analysis.IgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+                                frozenDictionary =  new OrdinalStringFrozenDictionary_LeftJustifiedSingleChar<TValue>(keys, values, stringComparer, comparison, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex);
                             }
                             else
                             {
-                                frozenDictionary = analysis.IgnoreCase
-                                    ? new OrdinalStringFrozenDictionary_LeftJustifiedSubstringCaseInsensitive<TValue>(keys, values, stringComparer, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex, analysis.HashCount)
-                                    : new OrdinalStringFrozenDictionary_LeftJustifiedSubstring<TValue>(keys, values, stringComparer, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex, analysis.HashCount);
+                                var comparison = analysis.IgnoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+                                frozenDictionary = new OrdinalStringFrozenDictionary_LeftJustifiedSubstring<TValue>(keys, values, stringComparer, comparison, analysis.MinimumLength, analysis.MaximumLengthDiff, analysis.HashIndex, analysis.HashCount);
                             }
                         }
                     }

src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/String/OrdinalStringFrozenDictionary_LeftJustifiedSingleChar.cs

@@ -7,23 +7,27 @@ namespace System.Collections.Frozen
 {
     internal sealed class OrdinalStringFrozenDictionary_LeftJustifiedSingleChar<TValue> : OrdinalStringFrozenDictionary<TValue>
     {
+        private StringComparison _comparison;
+
         internal OrdinalStringFrozenDictionary_LeftJustifiedSingleChar(
             string[] keys,
             TValue[] values,
             IEqualityComparer<string> comparer,
+            StringComparison comparison,
             int minimumLength,
             int maximumLengthDiff,
             int hashIndex)
             : base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, 1)
         {
+            _comparison = comparison;
         }
 
         // This override is necessary to force the jit to emit the code in such a way that it
         // avoids virtual dispatch overhead when calling the Equals/GetHashCode methods. Don't
         // remove this, or you'll tank performance.
         private protected override ref readonly TValue GetValueRefOrNullRefCore(string key) => ref base.GetValueRefOrNullRefCore(key);
 
-        private protected override bool Equals(string? x, string? y) => string.Equals(x, y);
+        private protected override bool Equals(string? x, string? y) => string.Equals(x, y, _comparison);
         private protected override int GetHashCode(string s) => s[HashIndex];
     }
 }

src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/String/OrdinalStringFrozenDictionary_LeftJustifiedSubstring.cs

@@ -7,24 +7,28 @@ namespace System.Collections.Frozen
 {
     internal sealed class OrdinalStringFrozenDictionary_LeftJustifiedSubstring<TValue> : OrdinalStringFrozenDictionary<TValue>
     {
+        private StringComparison _comparison;
+
         internal OrdinalStringFrozenDictionary_LeftJustifiedSubstring(
             string[] keys,
             TValue[] values,
             IEqualityComparer<string> comparer,
+            StringComparison comparison,
             int minimumLength,
             int maximumLengthDiff,
             int hashIndex,
             int hashCount)
             : base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
         {
+            _comparison = comparison;
         }
 
         // This override is necessary to force the jit to emit the code in such a way that it
         // avoids virtual dispatch overhead when calling the Equals/GetHashCode methods. Don't
         // remove this, or you'll tank performance.
         private protected override ref readonly TValue GetValueRefOrNullRefCore(string key) => ref base.GetValueRefOrNullRefCore(key);
 
-        private protected override bool Equals(string? x, string? y) => string.Equals(x, y);
+        private protected override bool Equals(string? x, string? y) => string.Equals(x, y, _comparison);
         private protected override int GetHashCode(string s) => Hashing.GetHashCodeOrdinal(s.AsSpan(HashIndex, HashCount));
     }
 }

src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/String/OrdinalStringFrozenDictionary_RightJustifiedSingleChar.cs

@@ -7,23 +7,27 @@ namespace System.Collections.Frozen
 {
     internal sealed class OrdinalStringFrozenDictionary_RightJustifiedSingleChar<TValue> : OrdinalStringFrozenDictionary<TValue>
     {
+        private StringComparison _comparison;
+
         internal OrdinalStringFrozenDictionary_RightJustifiedSingleChar(
             string[] keys,
             TValue[] values,
             IEqualityComparer<string> comparer,
+            StringComparison comparison,
             int minimumLength,
             int maximumLengthDiff,
             int hashIndex)
             : base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, 1)
         {
+            _comparison = comparison;
         }
 
         // This override is necessary to force the jit to emit the code in such a way that it
         // avoids virtual dispatch overhead when calling the Equals/GetHashCode methods. Don't
         // remove this, or you'll tank performance.
         private protected override ref readonly TValue GetValueRefOrNullRefCore(string key) => ref base.GetValueRefOrNullRefCore(key);
 
-        private protected override bool Equals(string? x, string? y) => string.Equals(x, y);
+        private protected override bool Equals(string? x, string? y) => string.Equals(x, y, _comparison);
         private protected override int GetHashCode(string s) => s[s.Length + HashIndex];
     }
 }

src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/String/OrdinalStringFrozenDictionary_RightJustifiedSubstring.cs

@@ -7,24 +7,28 @@ namespace System.Collections.Frozen
 {
     internal sealed class OrdinalStringFrozenDictionary_RightJustifiedSubstring<TValue> : OrdinalStringFrozenDictionary<TValue>
     {
+        private StringComparison _comparison;
+
         internal OrdinalStringFrozenDictionary_RightJustifiedSubstring(
             string[] keys,
             TValue[] values,
             IEqualityComparer<string> comparer,
+            StringComparison comparison,
             int minimumLength,
             int maximumLengthDiff,
             int hashIndex,
             int hashCount)
             : base(keys, values, comparer, minimumLength, maximumLengthDiff, hashIndex, hashCount)
         {
+            _comparison = comparison;
         }
 
         // This override is necessary to force the jit to emit the code in such a way that it
         // avoids virtual dispatch overhead when calling the Equals/GetHashCode methods. Don't
         // remove this, or you'll tank performance.
         private protected override ref readonly TValue GetValueRefOrNullRefCore(string key) => ref base.GetValueRefOrNullRefCore(key);
 
-        private protected override bool Equals(string? x, string? y) => string.Equals(x, y);
+        private protected override bool Equals(string? x, string? y) => string.Equals(x, y, _comparison);
         private protected override int GetHashCode(string s) => Hashing.GetHashCodeOrdinal(s.AsSpan(s.Length + HashIndex, HashCount));
     }
 }