performance and allocation improvements

Author: soenneker

src/Constructors/CachedConstructors.cs

@@ -1,157 +1,120 @@
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using Soenneker.Extensions.Array.Object;
+using Soenneker.Extensions.Array.Object;
 using Soenneker.Extensions.Type.Array;
 using Soenneker.Reflection.Cache.Constructors.Abstract;
 using Soenneker.Reflection.Cache.Extensions;
 using Soenneker.Reflection.Cache.Types;
+using System;
+using System.Collections.Frozen;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Threading;
 
 namespace Soenneker.Reflection.Cache.Constructors;
 
-///<inheritdoc cref="ICachedConstructors"/>
+/// <inheritdoc cref="ICachedConstructors"/>
 public sealed class CachedConstructors : ICachedConstructors
 {
     private readonly Lazy<CachedConstructor[]> _cachedArray;
-    private readonly Lazy<Dictionary<int, CachedConstructor>> _cachedDict;
-
-    private readonly CachedType _cachedType;
-    private readonly CachedTypes _cachedTypes;
-
+    private readonly Lazy<FrozenDictionary<int, CachedConstructor>> _cachedDict;
     private readonly Lazy<ConstructorInfo?[]> _cachedConstructorInfos;
 
+    // Fast path for parameterless construction (if available)
+    private readonly Lazy<Func<object?>> _parameterlessActivator;
+
     public CachedConstructors(CachedType cachedType, CachedTypes cachedTypes, bool threadSafe = true)
     {
-        _cachedType = cachedType;
-        _cachedTypes = cachedTypes;
+        CachedType cachedType1 = cachedType;
+        CachedTypes cachedTypes1 = cachedTypes;
 
-        _cachedArray = new Lazy<CachedConstructor[]>(() => SetArray(threadSafe), threadSafe);
-        _cachedDict = new Lazy<Dictionary<int, CachedConstructor>>(() => SetDict(threadSafe), threadSafe);
-        _cachedDict = new Lazy<Dictionary<int, CachedConstructor>>(() => SetDict(threadSafe), threadSafe);
+        LazyThreadSafetyMode mode = threadSafe ? LazyThreadSafetyMode.ExecutionAndPublication : LazyThreadSafetyMode.None;
 
-        _cachedConstructorInfos = new Lazy<ConstructorInfo?[]>(() => _cachedArray.Value.ToConstructorInfos(), threadSafe);
-    }
+        var constructorInfos = new Lazy<ConstructorInfo[]>(() => cachedType1.Type!.GetConstructors(cachedTypes1.Options.ConstructorFlags), mode);
 
-    public CachedConstructor? GetCachedConstructor(Type[]? parameterTypes = null)
-    {
-        int key = parameterTypes.ToHashKey();
-        return _cachedDict.Value.GetValueOrDefault(key);
-    }
-
-    public ConstructorInfo? GetConstructor(Type[]? parameterTypes = null)
-    {
-        return GetCachedConstructor(parameterTypes)?.ConstructorInfo;
-    }
-
-    private CachedConstructor[] SetArray(bool threadSafe)
-    {
-        if (_cachedDict.IsValueCreated)
+        _cachedArray = new Lazy<CachedConstructor[]>(() =>
         {
-            Dictionary<int, CachedConstructor>.ValueCollection cachedDictValues = _cachedDict.Value.Values;
-            var result = new CachedConstructor[cachedDictValues.Count];
-            var i = 0;
-
-            foreach (CachedConstructor constructor in cachedDictValues)
+            ConstructorInfo[] infos = constructorInfos.Value;
+            var result = new CachedConstructor[infos.Length];
+            for (var i = 0; i < infos.Length; i++)
             {
-                result[i++] = constructor;
+                result[i] = new CachedConstructor(infos[i], cachedTypes1, threadSafe);
             }
 
             return result;
-        }
-
-        ConstructorInfo[] constructorInfos = _cachedType.Type!.GetConstructors(_cachedTypes.Options.ConstructorFlags);
-        int length = constructorInfos.Length;
-
-        var cachedConstructors = new CachedConstructor[length];
-
-        for (var i = 0; i < length; i++)
-        {
-            cachedConstructors[i] = new CachedConstructor(constructorInfos[i], _cachedTypes, threadSafe);
-        }
-
-        return cachedConstructors;
-    }
+        }, mode);
 
-    private Dictionary<int, CachedConstructor> SetDict(bool threadSafe)
-    {
-        if (_cachedArray.IsValueCreated)
+        _cachedDict = new Lazy<FrozenDictionary<int, CachedConstructor>>(() =>
         {
-            CachedConstructor[] cachedArrayValue = _cachedArray.Value;
-            int length = cachedArrayValue.Length;
-
-            var dict = new Dictionary<int, CachedConstructor>(length);
-
-            for (var i = 0; i < length; i++)
+            CachedConstructor[] arr = _cachedArray.Value;
+            var dict = new Dictionary<int, CachedConstructor>(arr.Length);
+            for (var i = 0; i < arr.Length; i++)
             {
-                int key = cachedArrayValue[i].ToHashKey();
-                dict[key] = cachedArrayValue[i];
+                dict[arr[i].ToHashKey()] = arr[i]; // last-one-wins for duplicate sig hashes
             }
 
-            return dict;
-        }
-
-        ConstructorInfo[] constructorInfos = _cachedType.Type!.GetConstructors(_cachedTypes.Options.ConstructorFlags);
-        int constructorInfosLength = constructorInfos.Length;
+            return dict.ToFrozenDictionary();
+        }, mode);
 
-        var constructorsDict = new Dictionary<int, CachedConstructor>(constructorInfosLength);
+        _cachedConstructorInfos = new Lazy<ConstructorInfo?[]>(() => _cachedArray.Value.ToConstructorInfos(), mode);
 
-        ReadOnlySpan<ConstructorInfo> constructorsSpan = constructorInfos;
-
-        for (var i = 0; i < constructorInfosLength; i++)
+        _parameterlessActivator = new Lazy<Func<object?>>(() =>
         {
-            ConstructorInfo info = constructorsSpan[i];
-
-            ParameterInfo[] parameters = info.GetParameters();
-
-            int parametersLength = parameters.Length;
+            Type type = cachedType1.Type!;
+            ConstructorInfo? ctor = type.GetConstructor(Type.EmptyTypes);
+            if (ctor is null)
+                return static () => null;
 
-            var parameterTypes = new Type[parametersLength];
-
-            ReadOnlySpan<ParameterInfo> parametersSpan = parameters;
-
-            for (var j = 0; j < parametersLength; j++)
+            try
             {
-                parameterTypes[j] = parametersSpan[j].ParameterType;
+                // Build: () => new T()
+                NewExpression newExpr = Expression.New(ctor);
+                Expression<Func<object?>> lambda = Expression.Lambda<Func<object?>>(Expression.Convert(newExpr, typeof(object)));
+                return lambda.Compile();
             }
-
-            int key = parameterTypes.ToHashKey();
-
-            constructorsDict[key] = new CachedConstructor(info, _cachedTypes, threadSafe);
-        }
-
-        return constructorsDict;
+            catch
+            {
+                return () => Activator.CreateInstance(type);
+            }
+        }, mode);
     }
 
-    public CachedConstructor[] GetCachedConstructors()
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public CachedConstructor? GetCachedConstructor(Type[]? parameterTypes = null)
     {
-        return _cachedArray.Value;
+        int key = parameterTypes.ToHashKey();
+        return _cachedDict.Value.GetValueOrDefault(key);
     }
 
-    public ConstructorInfo?[] GetConstructors()
-    {
-        return _cachedConstructorInfos.Value;
-    }
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ConstructorInfo? GetConstructor(Type[]? parameterTypes = null) => GetCachedConstructor(parameterTypes)?.ConstructorInfo;
+
+    public CachedConstructor[] GetCachedConstructors() => _cachedArray.Value;
+
+    public ConstructorInfo?[] GetConstructors() => _cachedConstructorInfos.Value;
 
     public object? CreateInstance()
     {
-        //TODO: One day parameterless invoke of the constructorInfo may be faster than Activator.CreateInstance
-        return Activator.CreateInstance(_cachedType.Type!);
+        // Use the cached parameterless activator if present; otherwise null if no default ctor.
+        Func<object?> f = _parameterlessActivator.Value;
+        return f();
     }
 
     public T? CreateInstance<T>()
     {
-        return (T?)Activator.CreateInstance(_cachedType.Type!);
+        object? obj = CreateInstance();
+        return obj is null ? default : (T?) obj;
     }
-    
+
     public object? CreateInstance(params object[] parameters)
     {
         if (parameters.Length == 0)
             return CreateInstance();
 
+        // Avoid a LINQ pass; reuse your extension which is likely optimized.
         Type[] parameterTypes = parameters.ToTypes();
 
         CachedConstructor? cachedConstructor = GetCachedConstructor(parameterTypes);
-
         return cachedConstructor?.Invoke(parameters);
     }
 
@@ -163,10 +126,6 @@ public CachedConstructor[] GetCachedConstructors()
         Type[] parameterTypes = parameters.ToTypes();
 
         CachedConstructor? cachedConstructor = GetCachedConstructor(parameterTypes);
-
-        if (cachedConstructor == null)
-            return default;
-
-        return cachedConstructor.Invoke<T>(parameters);
+        return cachedConstructor is null ? default : cachedConstructor.Invoke<T>(parameters);
     }
 }

src/Fields/CachedFields.cs

@@ -1,7 +1,8 @@
 using System;
+using System.Collections.Frozen;
 using System.Collections.Generic;
 using System.Reflection;
-using Soenneker.Reflection.Cache.Extensions;
+using System.Runtime.CompilerServices;
 using Soenneker.Reflection.Cache.Fields.Abstract;
 using Soenneker.Reflection.Cache.Types;
 
@@ -10,95 +11,73 @@ namespace Soenneker.Reflection.Cache.Fields;
 ///<inheritdoc cref="ICachedFields"/>
 public sealed class CachedFields : ICachedFields
 {
-    private readonly Lazy<Dictionary<int, CachedField?>> _cachedDict;
-    private readonly Lazy<CachedField[]> _cachedArray;
-
-    private readonly Lazy<FieldInfo[]> _fieldsCache;
-
     private readonly CachedType _cachedType;
-
     private readonly CachedTypes _cachedTypes;
 
-    private readonly bool _threadSafe;
+    private readonly Lazy<BuiltCache> _built; // single source of truth
 
-    public CachedFields(CachedType cachedType, CachedTypes cachedTypes, bool threadSafe = true)
+    private sealed class BuiltCache
     {
-        _cachedType = cachedType;
-        _cachedTypes = cachedTypes;
-        _threadSafe = threadSafe;
+        public readonly CachedField[] CachedArray;
+        public readonly FrozenDictionary<string, CachedField> MapByName;
+        public readonly FieldInfo[] FieldInfos;
 
-        _cachedDict = new Lazy<Dictionary<int, CachedField?>>(SetDict, threadSafe);
-        _cachedArray = new Lazy<CachedField[]>(SetArray, threadSafe);
-        _fieldsCache = new Lazy<FieldInfo[]>(() => GetCachedFields().ToFieldInfos(), threadSafe);
+        public BuiltCache(CachedField[] cachedArray, FrozenDictionary<string, CachedField> mapByName, FieldInfo[] fieldInfos)
+        {
+            CachedArray = cachedArray;
+            MapByName = mapByName;
+            FieldInfos = fieldInfos;
+        }
     }
 
-    public FieldInfo? GetField(string name)
+    public CachedFields(CachedType cachedType, CachedTypes cachedTypes, bool threadSafe = true)
     {
-        CachedField? cachedField = GetCachedField(name);
-        return cachedField?.FieldInfo;
-    }
+        _cachedType = cachedType ?? throw new ArgumentNullException(nameof(cachedType));
+        _cachedTypes = cachedTypes ?? throw new ArgumentNullException(nameof(cachedTypes));
 
-    public CachedField? GetCachedField(string name)
-    {
-        return _cachedDict.Value.GetValueOrDefault(name.GetHashCode());
+        _built = new Lazy<BuiltCache>(BuildAll, threadSafe);
     }
 
-    private Dictionary<int, CachedField?> SetDict()
+    private BuiltCache BuildAll()
     {
-        var dict = new Dictionary<int, CachedField?>();
+        // One reflection hit + one allocation of FieldInfo[]
+        FieldInfo[] fields = _cachedType.Type!.GetFields(_cachedTypes.Options.FieldFlags);
+        int len = fields.Length;
 
-        // If the array is already populated, build the dictionary from the array
-        if (_cachedArray.IsValueCreated)
-        {
-            int length = _cachedArray.Value.Length;
+        var cached = new CachedField[len];
+        var dict = new Dictionary<string, CachedField>(len, StringComparer.Ordinal);
 
-            for (var index = 0; index < length; index++)
-            {
-                CachedField cachedField = _cachedArray.Value[index];
-                dict[cachedField.FieldInfo.Name.GetHashCode()] = cachedField;
-            }
-        }
-        else
+        for (var i = 0; i < len; i++)
         {
-            // If the array is not populated, build the dictionary directly
-            FieldInfo[] fields = _cachedType.Type!.GetFields(_cachedTypes.Options.FieldFlags);
-
-            int length = fields.Length;
-
-            for (var i = 0; i < length; i++)
-            {
-                FieldInfo field = fields[i];
-                var cachedField = new CachedField(field, _cachedTypes, _threadSafe);
-                dict[field.Name.GetHashCode()] = cachedField;
-            }
+            FieldInfo fi = fields[i];
+            var cf = new CachedField(fi, _cachedTypes, threadSafe: true); // thread safety here matches previous behavior
+            cached[i] = cf;
+            dict[fi.Name] = cf; // field names are unique per type for given BindingFlags
         }
 
-        return dict;
+        return new BuiltCache(
+            cached,
+            dict.ToFrozenDictionary(StringComparer.Ordinal),
+            fields // keep original FieldInfo[] so we don't re-convert later
+        );
     }
 
-    private CachedField[] SetArray()
-    {
-        if (_cachedDict.IsValueCreated)
-        {
-            Dictionary<int, CachedField?>.ValueCollection values = _cachedDict.Value.Values;
-            int count = values.Count;
-            var result = new CachedField[count];
-            values.CopyTo(result, 0);
-            return result;
-        }
-
-        FieldInfo[] fields = _cachedType.Type!.GetFields(_cachedTypes.Options.FieldFlags);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public FieldInfo? GetField(string name)
+        => GetCachedField(name)?.FieldInfo;
 
-        return fields.ToCachedFields(_cachedTypes, _threadSafe);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public CachedField? GetCachedField(string name)
+    {
+        // Fast, allocation-free lookup
+        return _built.Value.MapByName.GetValueOrDefault(name);
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public FieldInfo[] GetFields()
-    {
-        return _fieldsCache.Value;
-    }
+        => _built.Value.FieldInfos;
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public CachedField[] GetCachedFields()
-    {
-        return _cachedArray.Value;
-    }
+        => _built.Value.CachedArray;
 }