Cache reflection lookups in DynamicDataOperations

The Get*ConsideringInheritance methods (for fields, properties, and methods) walk the full type hierarchy via reflection on every call. This adds a ConcurrentDictionary cache per member kind, keyed by a (Type, memberName) struct, so the hierarchy walk happens only once per unique pair.

Uses a custom TypeMemberKey struct instead of ValueTuple for net462 compatibility.

Author: Evangelink

src/TestFramework/TestFramework/Attributes/DataSource/DynamicDataOperations.cs

@@ -7,6 +7,10 @@ internal static class DynamicDataOperations
 {
     private const BindingFlags DeclaredOnlyLookup = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
 
+    private static readonly ConcurrentDictionary<TypeMemberKey, FieldInfo?> FieldCache = new();
+    private static readonly ConcurrentDictionary<TypeMemberKey, PropertyInfo?> PropertyCache = new();
+    private static readonly ConcurrentDictionary<TypeMemberKey, MethodInfo?> MethodCache = new();
+
     public static IEnumerable<object[]> GetData(Type? dynamicDataDeclaringType, DynamicDataSourceType dynamicDataSourceType, string dynamicDataSourceName, object?[] dynamicDataSourceArguments, MethodInfo methodInfo)
     {
         // Check if the declaring type of test data is passed in. If not, default to test method's class type.
@@ -167,6 +171,15 @@ private static bool TryGetData(object dataSource, [NotNullWhen(true)] out IEnume
     }
 
     private static FieldInfo? GetFieldConsideringInheritance(Type type, string fieldName)
+        => FieldCache.GetOrAdd(new TypeMemberKey(type, fieldName), static key => LookupFieldInHierarchy(key.Type, key.Name));
+
+    private static PropertyInfo? GetPropertyConsideringInheritance(Type type, string propertyName)
+        => PropertyCache.GetOrAdd(new TypeMemberKey(type, propertyName), static key => LookupPropertyInHierarchy(key.Type, key.Name));
+
+    private static MethodInfo? GetMethodConsideringInheritance(Type type, string methodName)
+        => MethodCache.GetOrAdd(new TypeMemberKey(type, methodName), static key => LookupMethodInHierarchy(key.Type, key.Name));
+
+    private static FieldInfo? LookupFieldInHierarchy(Type type, string fieldName)
     {
         // NOTE: Don't use GetRuntimeField. It considers inheritance only for instance fields.
         Type? currentType = type;
@@ -184,7 +197,7 @@ private static bool TryGetData(object dataSource, [NotNullWhen(true)] out IEnume
         return null;
     }
 
-    private static PropertyInfo? GetPropertyConsideringInheritance(Type type, string propertyName)
+    private static PropertyInfo? LookupPropertyInHierarchy(Type type, string propertyName)
     {
         // NOTE: Don't use GetRuntimeProperty. It considers inheritance only for instance properties.
         Type? currentType = type;
@@ -202,7 +215,7 @@ private static bool TryGetData(object dataSource, [NotNullWhen(true)] out IEnume
         return null;
     }
 
-    private static MethodInfo? GetMethodConsideringInheritance(Type type, string methodName)
+    private static MethodInfo? LookupMethodInHierarchy(Type type, string methodName)
     {
         // NOTE: Don't use GetRuntimeMethod. It considers inheritance only for instance methods.
         Type? currentType = type;
@@ -219,4 +232,29 @@ private static bool TryGetData(object dataSource, [NotNullWhen(true)] out IEnume
 
         return null;
     }
+
+    private readonly struct TypeMemberKey : IEquatable<TypeMemberKey>
+    {
+        public TypeMemberKey(Type type, string name)
+        {
+            Type = type;
+            Name = name;
+        }
+
+        public Type Type { get; }
+
+        public string Name { get; }
+
+        public bool Equals(TypeMemberKey other) => Type == other.Type && Name == other.Name;
+
+        public override bool Equals(object? obj) => obj is TypeMemberKey other && Equals(other);
+
+        public override int GetHashCode()
+        {
+            int h1 = Type.GetHashCode();
+            int h2 = StringComparer.Ordinal.GetHashCode(Name);
+
+            return ((h1 << 5) + h1) ^ h2;
+        }
+    }
 }