Speed up case-insensitive Enum parsing

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/EnumInfo.cs

@@ -8,6 +8,7 @@
 using System.Runtime;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Threading;
 
 namespace System.Reflection
 {
@@ -41,6 +42,39 @@ public EnumInfo(Type underlyingType, TStorage[] values, string[] names, bool isF
         internal TStorage[] Values { get; }
         internal bool ValuesAreSequentialFromZero { get; }
 
+        // Lazily-built, cached case-insensitive name-to-value lookup used to accelerate
+        // case-insensitive parsing. Null until the first case-insensitive parse of this enum type.
+        private Dictionary<string, TStorage>? _namesToValuesIgnoreCase;
+
+        /// <summary>
+        /// Gets a case-insensitive name-to-value lookup, building and caching it on first use.
+        /// </summary>
+        public Dictionary<string, TStorage> GetNamesToValuesIgnoreCase()
+        {
+            return Volatile.Read(ref _namesToValuesIgnoreCase) ?? Initialize();
+
+            Dictionary<string, TStorage> Initialize()
+            {
+                string[] names = Names;
+                TStorage[] values = Values;
+                var lookup = new Dictionary<string, TStorage>(names.Length, StringComparer.OrdinalIgnoreCase);
+
+                // Insert in Names order (which is sorted by value). For names that differ only by case,
+                // TryAdd keeps the first (lowest-value) entry, matching the original linear scan's
+                // "first match wins" behavior.
+                for (int i = 0; i < names.Length; i++)
+                {
+                    lookup.TryAdd(names[i], values[i]);
+                }
+
+                // Publish atomically. If another thread raced and already published a lookup,
+                // reuse theirs so every caller observes a single cached instance. The fast-path
+                // Volatile.Read pairs an acquire load with this release publish so readers always
+                // observe a fully-initialized dictionary.
+                return Interlocked.CompareExchange(ref _namesToValuesIgnoreCase, lookup, null) ?? lookup;
+            }
+        }
+
         /// <summary>Create a copy of <see cref="Values"/>.</summary>
         public unsafe TResult[] CloneValues<TResult>() where TResult : struct
         {

src/libraries/System.Private.CoreLib/src/System/Enum.EnumInfo.cs

@@ -1,9 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Numerics;
 using System.Runtime.InteropServices;
+using System.Threading;
 
 namespace System
 {
@@ -17,6 +19,10 @@ internal sealed partial class EnumInfo<TStorage>
             public readonly TStorage[] Values;
             public readonly string[] Names;
 
+            // Lazily-built, cached case-insensitive name-to-value lookup used to accelerate
+            // case-insensitive parsing. Null until the first case-insensitive parse of this enum type.
+            private Dictionary<string, TStorage>? _namesToValuesIgnoreCase;
+
             // Each entry contains a list of sorted pair of enum field names and values, sorted by values
             public EnumInfo(bool hasFlagsAttribute, TStorage[] values, string[] names)
             {
@@ -32,6 +38,35 @@ public EnumInfo(bool hasFlagsAttribute, TStorage[] values, string[] names)
                 ValuesAreSequentialFromZero = AreSequentialFromZero(values);
             }
 
+            /// <summary>
+            /// Gets a case-insensitive name-to-value lookup, building and caching it on first use.
+            /// </summary>
+            public Dictionary<string, TStorage> GetNamesToValuesIgnoreCase()
+            {
+                return Volatile.Read(ref _namesToValuesIgnoreCase) ?? Initialize();
+
+                Dictionary<string, TStorage> Initialize()
+                {
+                    string[] names = Names;
+                    TStorage[] values = Values;
+                    var lookup = new Dictionary<string, TStorage>(names.Length, StringComparer.OrdinalIgnoreCase);
+
+                    // Insert in Names order (which is sorted by value). For names that differ only by case,
+                    // TryAdd keeps the first (lowest-value) entry, matching the original linear scan's
+                    // "first match wins" behavior.
+                    for (int i = 0; i < names.Length; i++)
+                    {
+                        lookup.TryAdd(names[i], values[i]);
+                    }
+
+                    // Publish atomically. If another thread raced and already published a lookup,
+                    // reuse theirs so every caller observes a single cached instance. The fast-path
+                    // Volatile.Read pairs an acquire load with this release publish so readers always
+                    // observe a fully-initialized dictionary.
+                    return Interlocked.CompareExchange(ref _namesToValuesIgnoreCase, lookup, null) ?? lookup;
+                }
+            }
+
             /// <summary>Create a copy of <see cref="Values"/>.</summary>
             public unsafe TResult[] CloneValues<TResult>() where TResult : struct
             {

src/libraries/System.Private.CoreLib/src/System/Enum.cs

@@ -6,6 +6,7 @@
 #define RARE_ENUMS
 #endif
 
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
@@ -1052,6 +1053,12 @@ private static bool TryParseByName<TStorage>(RuntimeType enumType, ReadOnlySpan<
 
             bool parsed = true;
             TStorage localResult = default;
+
+            // For case-insensitive parsing, use a cached name->value lookup and match spans without allocating.
+            Dictionary<string, TStorage>.AlternateLookup<ReadOnlySpan<char>> ignoreCaseLookup = ignoreCase ?
+                enumInfo.GetNamesToValuesIgnoreCase().GetAlternateLookup<ReadOnlySpan<char>>() :
+                default;
+
             while (value.Length > 0)
             {
                 // Find the next separator.
@@ -1080,14 +1087,10 @@ private static bool TryParseByName<TStorage>(RuntimeType enumType, ReadOnlySpan<
                 bool success = false;
                 if (ignoreCase)
                 {
-                    for (int i = 0; i < enumNames.Length; i++)
+                    if (ignoreCaseLookup.TryGetValue(subvalue, out TStorage matchedValue))
                     {
-                        if (subvalue.EqualsOrdinalIgnoreCase(enumNames[i]))
-                        {
-                            localResult |= enumValues[i];
-                            success = true;
-                            break;
-                        }
+                        localResult |= matchedValue;
+                        success = true;
                     }
                 }
                 else