Use single dictionary in DefaultMemberAccessStrategy (#782)

* add Lock shim

Author: lahma

Fluid/Ast/TextSpanStatement.cs

@@ -7,7 +7,7 @@ namespace Fluid.Ast
     public sealed class TextSpanStatement : Statement
     {
         private bool _isBufferPrepared;
-        private readonly object _synLock = new();
+        private readonly Lock _synLock = new();
         private TextSpan _text;
         internal string _preparedBuffer;
 
@@ -178,4 +178,4 @@ static async ValueTask<Completion> Awaited(Task task)
             return new ValueTask<Completion>(Completion.Normal);
         }
     }
-}
+}

Fluid/DefaultMemberAccessStrategy.cs

@@ -5,9 +5,11 @@ namespace Fluid
 {
     public class DefaultMemberAccessStrategy : MemberAccessStrategy
     {
-        private readonly object _synLock = new();
+        private readonly Lock _synLock = new();
 
-        private Dictionary<Type, Dictionary<string, IMemberAccessor>> _map = new Dictionary<Type, Dictionary<string, IMemberAccessor>>();
+        private readonly record struct Key(Type Type, string Name);
+
+        private Dictionary<Key, IMemberAccessor> _map = new();
 
         public override IMemberAccessor GetAccessor(Type type, string name)
         {
@@ -51,16 +53,7 @@ private IMemberAccessor GetAccessorUnlikely(Type type, string name)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private bool TryGetAccessor(Type type, string name, out IMemberAccessor accessor)
         {
-            if (_map.TryGetValue(type, out var typeMap))
-            {
-                if (typeMap.TryGetValue(name, out accessor) || typeMap.TryGetValue("*", out accessor))
-                {
-                    return true;
-                }
-            }
-
-            accessor = null;
-            return false;
+            return _map.TryGetValue(new Key(type, name), out accessor) || _map.TryGetValue(new Key(type, "*"), out accessor);
         }
 
         public override void Register(Type type, IEnumerable<KeyValuePair<string, IMemberAccessor>> accessors)
@@ -75,29 +68,39 @@ public override void Register(Type type, IEnumerable<KeyValuePair<string, IMembe
             lock (_synLock)
             {
                 // Clone current dictionary
-                var temp = new Dictionary<Type, Dictionary<string, IMemberAccessor>>(_map);
+                var temp = IgnoreCasing
+                    ? new Dictionary<Key, IMemberAccessor>(_map, KeyIgnoreCaseComparer.Instance)
+                    : new Dictionary<Key, IMemberAccessor>(_map);
 
-                // Clone inner dictionaries
-                foreach (var typeEntry in temp)
+                foreach (var accessor in accessors)
                 {
-                    var entry = new Dictionary<string, IMemberAccessor>(typeEntry.Value);
+                    temp[new Key(type, accessor.Key)] = accessor.Value;
                 }
 
-                if (!temp.TryGetValue(type, out var typeMap))
-                {
-                    typeMap = new Dictionary<string, IMemberAccessor>(IgnoreCasing
-                        ? StringComparer.OrdinalIgnoreCase
-                        : StringComparer.Ordinal);
+                _map = temp;
+            }
+        }
 
-                    temp[type] = typeMap;
-                }
+        private sealed class KeyIgnoreCaseComparer : IEqualityComparer<Key>
+        {
+            public static readonly KeyIgnoreCaseComparer Instance = new();
 
-                foreach (var accessor in accessors)
-                {
-                    typeMap[accessor.Key] = accessor.Value;
-                }
+            private KeyIgnoreCaseComparer()
+            {
+            }
 
-                _map = temp;
+            public bool Equals(Key x, Key y)
+            {
+                return x.Type == y.Type && string.Equals(x.Name, y.Name, StringComparison.OrdinalIgnoreCase);
+            }
+
+            public int GetHashCode(Key obj)
+            {
+#if NET6_0_OR_GREATER
+                return HashCode.Combine(obj.Type, obj.Name.GetHashCode(StringComparison.OrdinalIgnoreCase));
+#else
+                return obj.Type.GetHashCode() ^ obj.Name.ToUpperInvariant().GetHashCode();
+#endif
             }
         }
     }

Fluid/Shims.cs

@@ -1,32 +1,34 @@
-#if !NET6_0_OR_GREATER
-using System.Runtime.CompilerServices;
-
 #nullable enable
 
 namespace Fluid
 {
+#if !NET6_0_OR_GREATER
     /// <summary>
     /// Filling missing bits between netstandard2.0 and higher libs and frameworks.
     /// </summary>
     internal static class Shims
     {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static string[] Split(this string s, string? separator, StringSplitOptions options = StringSplitOptions.None)
         {
-            return s.Split(new[] { separator }, options);
+            return s.Split([separator], options);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining | (MethodImplOptions)512)]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static bool EndsWith(this string s, char c)
         {
             return s.Length > 0 && s[^1] == c;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
         public static bool Contains(this string s, char c)
         {
             return s.IndexOf(c) != -1;
         }
     }
-}
 #endif
+
+#if !NET9_0_OR_GREATER
+    internal sealed class Lock;
+#endif
+}