C# reflection optimization

<T, object>)_delegateCache.GetOrAdd(key, _ => { var property = typeof(T).GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance); if (property == null) throw new MissingMemberException(typeof(T).Name, propertyName);

        var instance = Expression.Parameter(typeof(T), "instance");
        var propertyAccess = Expression.Property(instance, property);
        var convert = Expression.Convert(propertyAccess, typeof(object));
        return Expression.Lambda<Func<T, object>>(convert, instance).Compile();
    });
}

}

Usage:
```csharp
var getter = DelegateCompiler.GetGetter<MyDto>("Id");
var value = getter(instance); // ~18ns, zero allocation

Step 4: Architecture Decisions & Rationale

• Cache scope: Type-level caching is safe and idiomatic. Avoid instance-level caches; they multiply memory pressure and defeat the purpose.
• Delegate compilation: Expression.Lambda.Compile() generates dynamic methods. It's fast after compilation but adds startup cost. Compile once per type/property pair.
• AOT/Trimming: Native AOT disables runtime delegate compilation. Use System.Reflection.Metadata for read-only metadata, or switch to Source Generators for frameworks targeting trimmed/AOT deployments.
• Thread safety: ConcurrentDictionary handles concurrency, but avoid GetOrAdd with heavy factories. Use Lazy<T> inside the value if delegate compilation might be contested.

Pitfall Guide

1. Caching MemberInfo but calling Invoke repeatedly
   PropertyInfo.GetValue and MethodInfo.Invoke perform runtime argument packing, security checks, and late binding. Caching the member only eliminates metadata lookup. Always compile to delegates for hot paths.

2. Ignoring BindingFlags defaults
   Calling GetProperties() without BindingFlags returns all members, including non-public and inherited ones. This increases enumeration time and allocation. Always specify BindingFlags.Public | BindingFlags.Instance unless you explicitly need otherwise.

3. Dictionary contention under high concurrency
   ConcurrentDictionary is thread-safe, but GetOrAdd with expensive factories can cause thread pooling delays. Wrap delegate compilation in Lazy<T> or use GetOrAdd with a pre-compiled factory to avoid lock contention.

4. Unbounded cache growth
   Caching every Type encountered in a dynamic system (e.g., JSON serializers) can cause memory leaks. Implement eviction policies (MemoryCache, ConditionalWeakTable, or size-limited dictionaries) for frameworks processing unbounded type sets.

5. AOT/Trimming incompatibility
   Runtime reflection and Expression.Compile fail in Native AOT or trimmed deployments. Guard with RuntimeFeature.IsDynamicCodeSupported and provide fallback paths (Source Generators, pre-compiled accessors, or metadata-only readers).

6. Profiling wall time instead of allocations
   Reflection's true cost is often Gen0 allocations from argument arrays and boxed values. Use dotnet-gc or BenchmarkDotNet allocation columns. Optimizing invocation time without addressing allocations yields diminishing returns.

7. Over-engineering cold paths
   Configuration loading, startup diagnostics, and admin endpoints rarely exceed 100 calls/second. Applying delegate compilation here adds complexity with zero measurable impact. Reserve optimization for hot paths only.

Production Bundle

Action Checklist

• Profile invocation frequency and allocation rates before optimizing
• Replace repeated GetProperty/GetMethod calls with ConcurrentDictionary caching
• Compile cached members to strongly-typed delegates using Expression.Lambda
• Add BindingFlags to all reflection enumeration calls to prevent hidden overhead
• Implement cache size limits or eviction for dynamic type processing
• Guard reflection-heavy code with RuntimeFeature.IsDynamicCodeSupported for AOT compatibility
• Benchmark delegate compilation startup cost vs runtime savings in your specific workload

Decision Matrix

Configuration Template

public sealed class ReflectionAccessorCache<T>
{
    private readonly ConcurrentDictionary<string, Func<T, object>> _getters = new();
    private readonly ConcurrentDictionary<string, Action<T, object>> _setters = new();

    public Func<T, object> GetGetter(string propertyName)
    {
        return _getters.GetOrAdd(propertyName, name =>
        {
            var prop = typeof(T).GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
            if (prop?.CanRead != true) throw new InvalidOperationException($"Property {name} not found or read-only.");

            var instance = Expression.Parameter(typeof(T));
            var access = Expression.Property(instance, prop);
            var convert = Expression.Convert(access, typeof(object));
            return Expression.Lambda<Func<T, object>>(convert, instance).Compile();
        });
    }

    public Action<T, object> GetSetter(string propertyName)
    {
        return _setters.GetOrAdd(propertyName, name =>
        {
            var prop = typeof(T).GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
            if (prop?.CanWrite != true) throw new InvalidOperationException($"Property {name} not found or write-only.");

            var instance = Expression.Parameter(typeof(T));
            var value = Expression.Parameter(typeof(object));
            var convert = Expression.Convert(value, prop.PropertyType);
            var assign = Expression.Assign(Expression.Property(instance, prop), convert);
            return Expression.Lambda<Action<T, object>>(assign, instance, value).Compile();
        });
    }
}

Quick Start Guide

1. Install dependencies: Add BenchmarkDotNet to your test project for validation. No runtime dependencies required.
2. Identify hot paths: Search for GetProperty, GetMethod, Activator.CreateInstance, or Invoke in your codebase. Filter by call frequency using profiling or logging.
3. Apply caching: Replace direct reflection calls with ConcurrentDictionary-backed caches. Use the provided ReflectionAccessorCache<T> template as a starting point.
4. Compile delegates: For paths exceeding 5k invocations/second, switch from GetValue/SetValue to compiled Func<T, object> and Action<T, object> delegates.
5. Validate deployment: Run dotnet publish -r win-x64 -p:PublishAot=true (or your target RID) to verify AOT compatibility. Add RuntimeFeature.IsDynamicCodeSupported guards where necessary.