Clean up

Author: SteveSandersonMS

src/Components/Components/src/Rendering/MultipleAttributesDictionary.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Runtime.CompilerServices;
 using Microsoft.AspNetCore.Components.RenderTree;
 
 namespace Microsoft.AspNetCore.Components.Rendering
@@ -27,7 +26,7 @@ public sealed class RenderTreeBuilder : IDisposable
         private readonly Stack<int> _openElementIndices = new Stack<int>();
         private RenderTreeFrameType? _lastNonAttributeFrameType;
         private bool _hasSeenAddMultipleAttributes;
-        private MultipleAttributesDictionary? _seenAttributeNames;
+        private Dictionary<string, int>? _seenAttributeNames;
 
         /// <summary>
         /// The reserved parameter name used for supplying child content.
@@ -707,21 +706,22 @@ internal void ProcessDuplicateAttributes(int first)
             }
 
             // Now that we've found the last attribute, we can iterate backwards and process duplicates.
-            var seenAttributeNames = (_seenAttributeNames ??= new MultipleAttributesDictionary());
+            var seenAttributeNames = (_seenAttributeNames ??= new Dictionary<string, int>(SimplifiedStringHashComparer.Instance));
             for (var i = last; i >= first; i--)
             {
                 ref var frame = ref buffer[i];
                 Debug.Assert(frame.FrameTypeField == RenderTreeFrameType.Attribute, $"Frame type is {frame.FrameTypeField} at {i}");
 
-                if (!seenAttributeNames.TryAdd(frame.AttributeNameField, i, out var index))
+                if (!seenAttributeNames.TryAdd(frame.AttributeNameField, i))
                 {
+                    var index = seenAttributeNames[frame.AttributeNameField];
                     if (index < i)
                     {
                         // This attribute is overriding a "silent frame" where we didn't create a frame for an AddAttribute call.
                         // This is the case for a null event handler, or bool false value.
                         //
                         // We need to update our tracking, in case the attribute appeared 3 or more times.
-                        seenAttributeNames.Replace(frame.AttributeNameField, i);
+                        seenAttributeNames[frame.AttributeNameField] = i;
                     }
                     else if (index > i)
                     {
@@ -778,8 +778,8 @@ internal void TrackAttributeName(string name)
                 return;
             }
 
-            var seenAttributeNames = (_seenAttributeNames ??= new MultipleAttributesDictionary());
-            seenAttributeNames.TryAdd(name, _entries.Count, out _); // See comment in ProcessAttributes for why this is OK.
+            var seenAttributeNames = (_seenAttributeNames ??= new Dictionary<string, int>(SimplifiedStringHashComparer.Instance));
+            seenAttributeNames[name] = _entries.Count; // See comment in ProcessAttributes for why this is OK.
         }
 
         void IDisposable.Dispose()

src/Components/Components/src/Rendering/RenderTreeBuilder.cs

@@ -0,0 +1,47 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.AspNetCore.Components.Rendering
+{
+    /// <summary>
+    /// This comparer is optimized for use with dictionaries where the great majority of insertions/lookups
+    /// don't match existing entries. For example, when building a dictionary of almost entirely unique keys.
+    /// It's faster than the normal string comparer in this case because it doesn't use string.GetHashCode,
+    /// and hence doesn't have to consider every character in the string.
+    ///
+    /// This primary scenario is <see cref="RenderTreeBuilder.ProcessDuplicateAttributes(int)"/>, which needs
+    /// to detect when one attribute is overriding another, but in the vast majority of cases attributes don't
+    /// actually override each other.
+    /// </summary>
+    internal class SimplifiedStringHashComparer : IEqualityComparer<string>
+    {
+        public readonly static SimplifiedStringHashComparer Instance = new SimplifiedStringHashComparer();
+
+        public bool Equals(string? x, string? y)
+        {
+            return string.Equals(x, y, StringComparison.OrdinalIgnoreCase);
+        }
+
+        public int GetHashCode(string key)
+        {
+            var keyLength = key.Length;
+            if (keyLength > 0)
+            {
+                // Consider just the length and middle and last characters.
+                // This will produce a distinct result for a sufficiently large
+                // proportion of attribute names.
+                return unchecked(
+                    char.ToLowerInvariant(key[keyLength - 1])
+                    + 31 * char.ToLowerInvariant(key[keyLength / 2])
+                    + 961 * keyLength);
+            }
+            else
+            {
+                return default;
+            }
+        }
+    }
+}