perf: Cache MakeGenericMethod calls in delegate factories

Add ConcurrentDictionary caches for MethodInfo instances created via
MakeGenericMethod in ModuleExecutionDelegateFactory and
ResultRepositoryDelegateFactory. This avoids repeated reflection calls
for the same type arguments.

Changes:
- Cache ExecuteAsync and ExecuteAndCastAsync generic method instances
  in ModuleExecutionDelegateFactory
- Cache GetResultAsync and GetResultAndCastAsync generic method instances
  in ResultRepositoryDelegateFactory
- Cache base method definitions as static readonly fields for reuse

Fixes #1474

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: thomhurst

src/ModularPipelines/Engine/Execution/ModuleExecutionDelegateFactory.cs

@@ -28,6 +28,22 @@ internal delegate Task<IModuleResult> ExecuteModuleDelegate(
 
     private static readonly ConcurrentDictionary<Type, ExecuteModuleDelegate> ExecutorCache = new();
 
+    /// <summary>
+    /// Cache for generic MethodInfo instances created via MakeGenericMethod.
+    /// Key is the result type, value is the specialized MethodInfo.
+    /// </summary>
+    private static readonly ConcurrentDictionary<Type, MethodInfo> ExecuteAsyncMethodCache = new();
+    private static readonly ConcurrentDictionary<Type, MethodInfo> ExecuteAndCastAsyncMethodCache = new();
+
+    /// <summary>
+    /// Base method definitions, cached once on first use.
+    /// </summary>
+    private static readonly MethodInfo ExecuteAsyncMethodDefinition =
+        typeof(IModuleExecutionPipeline).GetMethod(nameof(IModuleExecutionPipeline.ExecuteAsync))!;
+
+    private static readonly MethodInfo ExecuteAndCastAsyncMethodDefinition =
+        typeof(ModuleExecutionDelegateFactory).GetMethod(nameof(ExecuteAndCastAsync), BindingFlags.NonPublic | BindingFlags.Static)!;
+
     /// <summary>
     /// Gets a cached delegate for executing a module with the specified result type.
     /// </summary>
@@ -59,10 +75,10 @@ private static ExecuteModuleDelegate CreateExecutor(Type resultType)
         // Cast executionContext to ModuleExecutionContext<T>
         var castContext = Expression.Convert(contextParam, executionContextType);
 
-        // Get the ExecuteAsync method
-        var executeMethod = typeof(IModuleExecutionPipeline)
-            .GetMethod(nameof(IModuleExecutionPipeline.ExecuteAsync))!
-            .MakeGenericMethod(resultType);
+        // Get the ExecuteAsync method (cached)
+        var executeMethod = ExecuteAsyncMethodCache.GetOrAdd(
+            resultType,
+            static type => ExecuteAsyncMethodDefinition.MakeGenericMethod(type));
 
         // Call pipeline.ExecuteAsync<T>(module, executionContext, moduleContext, cancellationToken)
         var callExecute = Expression.Call(
@@ -74,10 +90,10 @@ private static ExecuteModuleDelegate CreateExecutor(Type resultType)
             cancellationTokenParam);
 
         // We need to create an async wrapper that awaits the task and casts the result to IModuleResult
-        // Since Expression trees can't directly represent async/await, we'll use a helper method
-        var helperMethod = typeof(ModuleExecutionDelegateFactory)
-            .GetMethod(nameof(ExecuteAndCastAsync), BindingFlags.NonPublic | BindingFlags.Static)!
-            .MakeGenericMethod(resultType);
+        // Since Expression trees can't directly represent async/await, we'll use a helper method (cached)
+        var helperMethod = ExecuteAndCastAsyncMethodCache.GetOrAdd(
+            resultType,
+            static type => ExecuteAndCastAsyncMethodDefinition.MakeGenericMethod(type));
 
         var callHelper = Expression.Call(
             helperMethod,

src/ModularPipelines/Engine/Execution/ResultRepositoryDelegateFactory.cs

@@ -22,6 +22,22 @@ internal static class ResultRepositoryDelegateFactory
 
     private static readonly ConcurrentDictionary<Type, GetResultDelegate> GetResultCache = new();
 
+    /// <summary>
+    /// Cache for generic MethodInfo instances created via MakeGenericMethod.
+    /// Key is the result type, value is the specialized MethodInfo.
+    /// </summary>
+    private static readonly ConcurrentDictionary<Type, MethodInfo> GetResultAsyncMethodCache = new();
+    private static readonly ConcurrentDictionary<Type, MethodInfo> GetResultAndCastAsyncMethodCache = new();
+
+    /// <summary>
+    /// Base method definitions, cached once on first use.
+    /// </summary>
+    private static readonly MethodInfo GetResultAsyncMethodDefinition =
+        typeof(IModuleResultRepository).GetMethod(nameof(IModuleResultRepository.GetResultAsync))!;
+
+    private static readonly MethodInfo GetResultAndCastAsyncMethodDefinition =
+        typeof(ResultRepositoryDelegateFactory).GetMethod(nameof(GetResultAndCastAsync), BindingFlags.NonPublic | BindingFlags.Static)!;
+
     /// <summary>
     /// Gets a cached delegate for calling GetResultAsync with the specified result type.
     /// </summary>
@@ -42,18 +58,18 @@ private static GetResultDelegate CreateGetResultDelegate(Type resultType)
         // Cast module to Module<T>
         var castModule = Expression.Convert(moduleParam, moduleType);
 
-        // Get the GetResultAsync<T> method
-        var method = typeof(IModuleResultRepository)
-            .GetMethod(nameof(IModuleResultRepository.GetResultAsync))!
-            .MakeGenericMethod(resultType);
+        // Get the GetResultAsync<T> method (cached)
+        var method = GetResultAsyncMethodCache.GetOrAdd(
+            resultType,
+            static type => GetResultAsyncMethodDefinition.MakeGenericMethod(type));
 
         // Call: repository.GetResultAsync<T>((Module<T>)module, context)
         var callMethod = Expression.Call(repositoryParam, method, castModule, contextParam);
 
-        // We need an async helper since expression trees can't represent async
-        var helperMethod = typeof(ResultRepositoryDelegateFactory)
-            .GetMethod(nameof(GetResultAndCastAsync), BindingFlags.NonPublic | BindingFlags.Static)!
-            .MakeGenericMethod(resultType);
+        // We need an async helper since expression trees can't represent async (cached)
+        var helperMethod = GetResultAndCastAsyncMethodCache.GetOrAdd(
+            resultType,
+            static type => GetResultAndCastAsyncMethodDefinition.MakeGenericMethod(type));
 
         var callHelper = Expression.Call(helperMethod, repositoryParam, castModule, contextParam);