perf: Cache constructed IOptions<T> types in OptionsProvider

[thomhurst]

Summary

• Adds a ConcurrentDictionary<Type, Type> cache for constructed IOptions<T> types
• Avoids repeated MakeGenericType calls in GetOptions() loop
• Uses static lambda for cache factory to avoid closure allocation

Changes

Before:

foreach (var option in _cachedOptionTypes.Select(t => _serviceProvider.GetService(typeof(IOptions<>).MakeGenericType(t))))

After:

foreach (var t in _cachedOptionTypes)
{
    var optionsType = IOptionsTypeCache.GetOrAdd(t, static innerType => typeof(IOptions<>).MakeGenericType(innerType));
    var option = _serviceProvider.GetService(optionsType);
    // ...
}

Test plan

• Build succeeds
• CI pipeline passes
• Existing tests pass

Fixes #1548

🤖 Generated with Claude Code

[thomhurst]

Summary

Adds caching for constructed IOptions<T> generic types to avoid repeated MakeGenericType() calls in the options provider hot path.

Critical Issues

None found ✅

Suggestions

Consider thread-safety pattern consistency: The new cache uses GetOrAdd with a static lambda (static innerType => typeof(IOptions<>).MakeGenericType(innerType)), which is excellent. However, I notice that:

1. Line 64 uses GetOrAdd with an instance method reference: ValueGetterCache.GetOrAdd(option.GetType(), CreateValueGetter)
2. The new code uses GetOrAdd with a static lambda

Both are correct, but for consistency, you might consider using a static lambda for the ValueGetterCache call as well:

var getter = ValueGetterCache.GetOrAdd(option.GetType(), static t => CreateValueGetter(t));

This is a minor style point - the current implementation is functionally correct and the optimization is sound.

Verification: The optimization makes sense given that _cachedOptionTypes is static and doesn't change after startup, so you'll be calling MakeGenericType() with the same types repeatedly. Caching these constructed types is a good micro-optimization.

Verdict

✅ APPROVE - No critical issues

The optimization is well-implemented and consistent with the existing performance-focused approach in this class. The use of static lambda prevents unnecessary closure allocations.

[Copilot]

Pull request overview

This PR introduces a performance optimization to the OptionsProvider class by caching constructed IOptions<T> types. The optimization reduces redundant MakeGenericType calls when iterating through option types.

Key Changes:

• Added a static ConcurrentDictionary<Type, Type> cache (IOptionsTypeCache) for constructed IOptions<T> types
• Modified the GetOptions() method to use the cache with a static lambda factory function
• Eliminates repeated generic type construction overhead during option enumeration