Soenneker.Reflection.Cache 4.0.676

Soenneker.Reflection.Cache

Caches reflection metadata, lookups, constructed generics, custom attributes, and compiled member accessors for repeated use.

Installation

dotnet add package Soenneker.Reflection.Cache

Registration

using Soenneker.Reflection.Cache.Registrars;

services.AddReflectionCacheAsSingleton();

A singleton gives the application one shared metadata graph and the highest cache reuse. Use AddReflectionCacheAsScoped() when metadata must stop being retained with a scope. The cache has no eviction API; its cached Type, member, attribute, and delegate references live as long as the cache does. Avoid a long-lived cache for types loaded into collectible AssemblyLoadContext instances.

For manual construction:

var cache = new ReflectionCache();

Thread safety is enabled by default. new ReflectionCache(threadSafe: false) removes concurrency protection and is suitable only when the cache instance is confined to one thread.

Follow the cached chain

CachedType cachedType = cache.GetCachedType(typeof(OrderHandler));

CachedMethod? method = cachedType.GetCachedMethod(
    nameof(OrderHandler.Handle),
    [typeof(Order)]);

CachedParameter[]? parameters = method?.GetCachedParameters()?.GetCachedParameters();
object? result = method?.Invoke(handler, order);

Methods returning CachedType, CachedMethod, CachedProperty, CachedField, CachedConstructor, and related wrappers keep subsequent reflection work inside the cache. Convenience methods such as GetMethod() and GetProperties() return the underlying reflection objects; operations performed directly on those objects are outside the cache.

Name-only method lookup returns the first cached method with that name. Use a parameter-type overload whenever overload selection matters.

Compiled property and field access

CachedProperty? property = cache
    .GetCachedType(typeof(Person))
    .GetCachedProperty(nameof(Person.Name));

if (property?.TrySetValue(person, "Jane") == true &&
    property.TryGetValue(person, out object? name))
{
    Console.WriteLine(name);
}

Compiled accessors support public instance, non-indexed members. Static and non-public accessors, indexers, open generic/by-ref-like/pointer member types, init-only property setters, readonly fields, and setters declared on value types do not produce delegates. TryGetValue/TrySetValue return false for unsupported or incompatible access; GetValue/SetValue throw instead.

Constructors, attributes, and generics

CachedType listDefinition = cache.GetCachedType(typeof(List<>));
CachedType? closedList = listDefinition.MakeGenericCachedType(typeof(string));

CachedConstructor? constructor = closedList?.GetCachedConstructor([]);
var values = constructor?.Invoke<List<string>>();

ObsoleteAttribute? obsolete = cachedType.GetCachedCustomAttribute<ObsoleteAttribute>();

Closed generic types and methods are cached by their type-argument sequence. Constructor and method wrappers also cache parameter metadata, attributes, and invocation preparation.

Binding flags

Manual construction accepts ReflectionCacheOptions when discovery should use different binding flags by category:

var options = new ReflectionCacheOptions
{
    MethodFlags = BindingFlags.Instance | BindingFlags.Public,
    PropertyFlags = BindingFlags.Instance | BindingFlags.Public
};

var cache = new ReflectionCache(options);

The selected flags become part of that cache's behavior. Create a separate cache when another component requires a different reflection scope.

String type lookup follows Type.GetType(string). Use an assembly-qualified name for types outside the calling assembly and core library. Failed name lookups are cached as unresolved results, so load required assemblies before the first lookup.

Benchmarks (.NET)

GetType() 5,772% faster

GetMethods() 24,842% faster

GetMethod() 37% faster

GetMembers() 83,924% faster

GetMember() 1,043% faster

GetProperties() 8,960% faster

GetProperty() 57% faster

GetFields() 419% faster

GetInterfaces() 1,439% faster

GetInterface() 144% faster

GetConstructors() 4,054% faster

GetConstructor() 601% faster

Activator.CreateInstance(params) vs cachedConstructor.CreateInstance(params) 242% faster

GetCustomAttributes() 1,658% faster

GetGenericTypeDefinition() 499% faster

IsAssignableFrom() 51% faster

MakeGenericType() 1,485% faster

GetElementType() 1,847% faster

Properties on Type (e.g. typeof(string).IsNullable)

Notes:

• These benchmarks are built over iterations. The first operation is going to be as slow as the Reflection it sits in front of.
• Many of these are based off of a test class TestType which is located in the test library.