Soenneker.Reflection.Cache 4.0.573

Soenneker.Reflection.Cache

The fastest .NET Reflection cache

Why?

System.Reflection is slow. If you need to call Reflection code repeatedly, this library can drastically speed up subsequent calls. It's thread-safe and supports concurrency.

Installation

dotnet add package Soenneker.Reflection.Cache

This cache can either be added to DI like so:

public void ConfigureServices(IServiceCollection services)
{
    services.AddReflectionCacheAsSingleton(); // or AddReflectionCacheAsScoped()
}

and you could access it like:

public class MyService
{
    private readonly IReflectionCache _cache;

    public MyService(IReflectionCache cache)
    {
        _cache = cache;
    }
}

or you can instantiate it manually:

var cache = new ReflectionCache(threadSafe: true); // can be disabled for extra speed

Usage

var type1 = Type.GetType("System.String"); // <-- regular Reflection
var type2 = cache.GetType("System.String"); // <-- cached Reflection
bool areEqual = type1 == type2; // true

Keep in mind:

cache.GetType("System.String"); // <-- as slow as regular Reflection
cache.GetType("System.String"); // <-- very fast because the first call was cached

⚠️ Important ⚠️

Be mindful of the "cache chain". Use the Cached methods and types until you need to get the final Reflection type you need from the cache.

There are two methods for most operations like this:

Type typeofString = cache.GetType("System.String"); // <-- caches, stops the cache chain
CachedType type = cache.GetCachedType("System.String"); // <-- caches, continues the cache chain

Scenario: Retrieving parameters from a method

✅ Good:

CachedType cachedType = cache.GetCachedType("System.String");
CachedMethod cachedMethodInfo = cachedType.GetCachedMethod("Intern");
ParameterInfo?[] parameters = cachedMethodInfo.GetParameters(); // < -- parameters are now cached

❌ Bad:

CachedType cachedType = cache.GetCachedType("System.String");
MethodInfo methodInfo = cachedType.GetMethod("Intern"); // <-- uh oh, a non-cached Reflection type
ParameterInfo?[] parameters = methodInfo.GetParameters(); // <-- not cached, repeat calls are slow

Tips

• Almost all of the Cached methods (e.g. GetCachedParameters() vs GetParameters() are faster due to the final preparation needed to match the System.Reflection methods.
• Work with the Cached objects instead of Reflection objects if possible. They're faster to retrieve and allow for more efficient downstream chaining.
• Thread safety can be disabled for more speed. It's enabled by default.
• Consider if caching is even necessary for your use case. If you're only calling Reflection once, it may not be worth it.
• Caching isn't free. Be thoughtful of your memory footprint and where/when you dispose of the cache.

Notes

• A cache removal mechanism is needing to be built yet.
• Many Reflection functionalities are not yet implemented, and could benefit from caching.
• If you see something that could be improved (performance or allocation), please open an issue or PR.

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.