Support returning object from invoke and fix lifetime issues

ejsmith · ejsmith · commit 7163d0cb3ed0 · 2025-09-22T23:22:34.000-05:00
diff --git a/src/Foundatio.Mediator.Abstractions/Mediator.cs b/src/Foundatio.Mediator.Abstractions/Mediator.cs
@@ -3,19 +3,22 @@
 using System.Text;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 
 namespace Foundatio.Mediator;
 
 public class Mediator : IMediator, IServiceProvider
 {
     private readonly IServiceProvider _serviceProvider;
     private readonly MediatorConfiguration _configuration;
+    private readonly ILogger<Mediator> _logger;
 
     [DebuggerStepThrough]
     public Mediator(IServiceProvider serviceProvider, MediatorConfiguration? configuration = null)
     {
         _serviceProvider = serviceProvider;
         _configuration = configuration ?? new MediatorConfiguration();
+        _logger = _serviceProvider.GetService<ILogger<Mediator>>() ?? NullLogger<Mediator>.Instance;
     }
 
     public IServiceProvider ServiceProvider => _serviceProvider;
@@ -36,14 +39,14 @@ public void Invoke(object message, CancellationToken cancellationToken = default
     public async ValueTask<TResponse> InvokeAsync<TResponse>(object message, CancellationToken cancellationToken = default)
     {
         var handlerFunc = GetInvokeAsyncResponseDelegate(message.GetType(), typeof(TResponse));
-        var result = await handlerFunc(this, message, cancellationToken);
+        object? result = await handlerFunc(this, message, cancellationToken);
         return (TResponse)result!;
     }
 
     public TResponse Invoke<TResponse>(object message, CancellationToken cancellationToken = default)
     {
         var handlerFunc = GetInvokeResponseDelegate(message.GetType(), typeof(TResponse));
-        var result = handlerFunc(this, message, cancellationToken);
+        object? result = handlerFunc(this, message, cancellationToken);
         return (TResponse)result!;
     }
 
@@ -55,11 +58,10 @@ public ValueTask PublishAsync(object message, CancellationToken cancellationToke
 
     public void ShowRegisteredHandlers()
     {
-        var logger = _serviceProvider.GetRequiredService<ILogger<Mediator>>();
         var registrations = _serviceProvider.GetServices<HandlerRegistration>().ToArray();
         if (!registrations.Any())
         {
-            logger.LogInformation("No handlers registered.");
+            _logger.LogInformation("No handlers registered.");
             return;
         }
 
@@ -70,7 +72,7 @@ public void ShowRegisteredHandlers()
             sb.AppendLine($"- Message: {registration.MessageTypeName}, Handler: {registration.HandlerClassName}, IsAsync: {registration.IsAsync}");
         }
 
-        logger.LogInformation(sb.ToString());
+        _logger.LogInformation(sb.ToString());
     }
 
     [DebuggerStepThrough]
@@ -225,13 +227,13 @@ private IEnumerable<HandlerRegistration> GetHandlersForType(Type type)
     public static T GetOrCreateMiddleware<T>(IServiceProvider serviceProvider) where T : class
     {
         // Check cache first - if it's there, it means it's not registered in DI
-        if (_middlewareCache.TryGetValue(typeof(T), out var cachedInstance))
+        if (_middlewareCache.TryGetValue(typeof(T), out object? cachedInstance))
             return (T)cachedInstance;
 
         // Try to get from DI - if registered, always use DI (respects service lifetime)
-        var middlewareFromDI = serviceProvider.GetService<T>();
-        if (middlewareFromDI != null)
-            return middlewareFromDI;
+        var middleware = serviceProvider.GetService<T>();
+        if (middleware != null)
+            return middleware;
 
         // Not in DI, create and cache our own instance
         return (T)_middlewareCache.GetOrAdd(typeof(T), type =>
@@ -263,9 +265,9 @@ public static T GetOrCreateMiddleware<T>(IServiceProvider serviceProvider) where
             if (asyncMethod == null)
                 return null;
 
-            HandleAsyncDelegate asyncDelegate = (IMediator mediator, object message, CancellationToken ct, Type? returnType) =>
+            HandleAsyncDelegate asyncDelegate = (mediator, message, ct, returnType) =>
             {
-                var taskObj = asyncMethod.Invoke(null, new object?[] { mediator, message, ct, returnType });
+                object? taskObj = asyncMethod.Invoke(null, [mediator, message, ct, returnType]);
                 return taskObj is ValueTask<object?> vt ? vt : (ValueTask<object?>)taskObj!;
             };
 
@@ -275,10 +277,7 @@ public static T GetOrCreateMiddleware<T>(IServiceProvider serviceProvider) where
                 var syncMethod = wrapperClosed.GetMethod("UntypedHandle", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
                 if (syncMethod != null)
                 {
-                    syncDelegate = (IMediator mediator, object message, CancellationToken ct, Type? returnType) =>
-                    {
-                        return syncMethod.Invoke(null, new object?[] { mediator, message, ct, returnType });
-                    };
+                    syncDelegate = (mediator, message, ct, returnType) => syncMethod.Invoke(null, [mediator, message, ct, returnType]);
                 }
             }
 
diff --git a/src/Foundatio.Mediator/DIRegistrationGenerator.cs b/src/Foundatio.Mediator/DIRegistrationGenerator.cs
@@ -16,6 +16,7 @@ public static void Execute(SourceProductionContext context, List<HandlerInfo> ha
         source.AddGeneratedFileHeader();
 
         source.AppendLine("using Microsoft.Extensions.DependencyInjection;");
+        source.AppendLine("using Microsoft.Extensions.DependencyInjection.Extensions;");
         source.AppendLine("using System;");
         source.AppendLine("using System.Diagnostics;");
         source.AppendLine("using System.Diagnostics.CodeAnalysis;");
@@ -33,54 +34,59 @@ public static void Execute(SourceProductionContext context, List<HandlerInfo> ha
         source.AppendLine("    public static void AddHandlers(this IServiceCollection services)");
         source.AppendLine("    {");
         source.AppendLine("        // Register HandlerRegistration instances keyed by message type name");
-        source.AppendLine("        // Optionally register handler classes into DI based on MediatorHandlerLifetime setting");
         source.AppendLine();
         source.IncrementIndent().IncrementIndent();
 
-        bool registerHandlers = !string.Equals(handlerLifetime, "None", StringComparison.OrdinalIgnoreCase);
+        string lifetimeMethod;
+        if (String.Equals(handlerLifetime, "Transient", StringComparison.OrdinalIgnoreCase))
+            lifetimeMethod = "TryAddTransient";
+        else if (String.Equals(handlerLifetime, "Scoped", StringComparison.OrdinalIgnoreCase))
+            lifetimeMethod = "TryAddScoped";
+        else
+            lifetimeMethod = "TryAddSingleton";
 
         foreach (var handler in handlers)
         {
             string handlerClassName = HandlerGenerator.GetHandlerClassName(handler);
 
             // Register handler in DI for non-static handler classes when lifetime != Singleton
-            if (registerHandlers && !handler.IsStatic)
+            if (handler is { IsStatic: false, IsGenericHandlerClass: false })
             {
-                string lifetimeMethod = "";
-                if (String.Equals(handlerLifetime, "Transient", StringComparison.OrdinalIgnoreCase))
-                    lifetimeMethod = "AddTransient";
-                if (String.Equals(handlerLifetime, "Scoped", StringComparison.OrdinalIgnoreCase))
-                    lifetimeMethod = "AddScoped";
-                if (String.Equals(handlerLifetime, "Singleton", StringComparison.OrdinalIgnoreCase))
-                    lifetimeMethod = "AddSingleton";
-
-                if (!String.IsNullOrEmpty(lifetimeMethod))
-                    source.AppendLine($"services.{lifetimeMethod}<{handler.FullName}>();");
+                source.AppendLine($"services.{lifetimeMethod}<{handler.FullName}>();");
             }
 
             if (handler.IsGenericHandlerClass)
             {
-                // open generic registration
                 if (handler is not { MessageGenericTypeDefinitionFullName: not null, GenericArity: > 0 })
                     continue;
 
-                // Build unbound generic typeof expressions
-                string wrapperTypeOf = handler.GenericArity switch
+                string genericArity = handler.GenericArity switch
                 {
-                    1 => $"typeof({handlerClassName}<>)",
-                    2 => $"typeof({handlerClassName}<,>)",
-                    3 => $"typeof({handlerClassName}<,,>)",
-                    4 => $"typeof({handlerClassName}<,,,>)",
-                    5 => $"typeof({handlerClassName}<,,,,>)",
-                    6 => $"typeof({handlerClassName}<,,,,,>)",
-                    7 => $"typeof({handlerClassName}<,,,,,,>)",
-                    8 => $"typeof({handlerClassName}<,,,,,,,>)",
-                    9 => $"typeof({handlerClassName}<,,,,,,,,>)",
-                    10 => $"typeof({handlerClassName}<,,,,,,,,,>)",
-                    _ => $"typeof({handlerClassName}<>)" // fallback
+                    1 => "<>",
+                    2 => "<,>",
+                    3 => "<,,>",
+                    4 => "<,,,>",
+                    5 => "<,,,,>",
+                    6 => "<,,,,,>",
+                    7 => "<,,,,,,>",
+                    8 => "<,,,,,,,>",
+                    9 => "<,,,,,,,,>",
+                    10 => "<,,,,,,,,,>",
+                    _ => "<>)" // fallback
                 };
+
+                string wrapperTypeOf = $"typeof({handlerClassName}{genericArity})";
                 string msgTypeOf = $"typeof({handler.MessageGenericTypeDefinitionFullName})";
-                source.AppendLine($"// Open generic handler registration for {handler.MessageGenericTypeDefinitionFullName}");
+                if (!handler.IsStatic)
+                {
+                    string handlerFullName = handler.FullName;
+                    int index = handlerFullName.IndexOf('<');
+                    if (index > 0)
+                        handlerFullName = handlerFullName.Substring(0, index);
+                    source.AppendLine($"services.{lifetimeMethod}(typeof({handlerFullName}{genericArity}));");
+
+                }
+
                 source.AppendLine($"services.AddSingleton(new OpenGenericHandlerDescriptor({msgTypeOf}, {wrapperTypeOf}, {handler.IsAsync.ToString().ToLower()}));");
             }
             else
diff --git a/src/Foundatio.Mediator/HandlerAnalyzer.cs b/src/Foundatio.Mediator/HandlerAnalyzer.cs
@@ -131,12 +131,12 @@ public static List<HandlerInfo> GetHandlers(GeneratorSyntaxContext context)
             if (classSymbol.IsGenericType)
             {
                 genericParamNames = classSymbol.TypeParameters.Select(tp => tp.Name).ToArray();
-                genericConstraints = classSymbol.TypeParameters.Select(tp => BuildConstraintClause(tp)).Where(s => s.Length > 0).ToArray();
+                genericConstraints = classSymbol.TypeParameters.Select(BuildConstraintClause).Where(s => s.Length > 0).ToArray();
             }
             else
             {
-                genericParamNames = Array.Empty<string>();
-                genericConstraints = Array.Empty<string>();
+                genericParamNames = [];
+                genericConstraints = [];
             }
 
             handlers.Add(new HandlerInfo
@@ -198,7 +198,7 @@ private static IEnumerable<IMethodSymbol> GetMethods(INamedTypeSymbol targetSymb
 
             foreach (var methodSymbol in methodSymbols)
             {
-                var signature = BuildMethodSignature(methodSymbol);
+                string signature = BuildMethodSignature(methodSymbol);
 
                 if (!methods.ContainsKey(signature))
                     methods.Add(signature, methodSymbol);
@@ -218,11 +218,11 @@ private static string BuildMethodSignature(IMethodSymbol method)
         if (method.Parameters.Length == 0)
             return method.Name + "()";
 
-        var parts = new string[method.Parameters.Length];
+        string[] parts = new string[method.Parameters.Length];
         for (int i = 0; i < method.Parameters.Length; i++)
             parts[i] = method.Parameters[i].Type.ToDisplayString();
 
-        return method.Name + "(" + string.Join(",", parts) + ")";
+        return method.Name + "(" + String.Join(",", parts) + ")";
     }
 
     private static readonly string[] ValidHandlerMethodNames = [
@@ -234,7 +234,6 @@ private static string BuildMethodSignature(IMethodSymbol method)
 
     private static string BuildConstraintClause(ITypeParameterSymbol tp)
     {
-        // Order: class/struct/unmanaged first, then specific constraint types, then notnull, then new()
         var ordered = new List<string>();
 
         if (tp.HasReferenceTypeConstraint)
@@ -246,8 +245,7 @@ private static string BuildConstraintClause(ITypeParameterSymbol tp)
 
         foreach (var c in tp.ConstraintTypes)
         {
-            var display = c.ToDisplayString();
-            // Avoid duplicating if already implicitly covered (rare, but defensive)
+            string display = c.ToDisplayString();
             if (!ordered.Contains(display))
                 ordered.Add(display);
         }
@@ -258,8 +256,8 @@ private static string BuildConstraintClause(ITypeParameterSymbol tp)
             ordered.Add("new()");
 
         if (ordered.Count == 0)
-            return string.Empty;
+            return String.Empty;
 
-        return $"where {tp.Name} : {string.Join(", ", ordered)}";
+        return $"where {tp.Name} : {String.Join(", ", ordered)}";
     }
 }
diff --git a/src/Foundatio.Mediator/HandlerGenerator.cs b/src/Foundatio.Mediator/HandlerGenerator.cs
@@ -569,27 +569,10 @@ private static void GenerateGetOrCreateHandler(IndentedStringBuilder source, Han
     {
         source.AppendLine()
               .AppendLines($$"""
-                private static {{handler.FullName}}? _handler;
-                private static readonly global::System.Threading.Lock _lock = new();
-
                 [DebuggerStepThrough]
                 private static {{handler.FullName}} GetOrCreateHandler(IServiceProvider serviceProvider)
                 {
-                    if (_handler != null)
-                        return _handler;
-
-                    var handlerFromDI = serviceProvider.GetService<{{handler.FullName}}>();
-                    if (handlerFromDI != null)
-                        return handlerFromDI;
-
-                    lock (_lock)
-                    {
-                        if (_handler != null)
-                            return _handler;
-
-                        _handler = ActivatorUtilities.CreateInstance<{{handler.FullName}}>(serviceProvider);
-                        return _handler;
-                    }
+                    return serviceProvider.GetRequiredService<{{handler.FullName}}>();
                 }
                 """);
     }
diff --git a/src/Foundatio.Mediator/Utility/Helpers.cs b/src/Foundatio.Mediator/Utility/Helpers.cs
@@ -37,17 +37,17 @@ private static string GetToolVersion()
 
     public static string ToIdentifier(this string name)
     {
-        if (string.IsNullOrEmpty(name))
+        if (String.IsNullOrEmpty(name))
             return String.Empty;
 
-        return new String(name.Select(c => char.IsLetterOrDigit(c) || c == '_' ? c : '_').ToArray());
+        return new string(name.Select(c => Char.IsLetterOrDigit(c) || c == '_' ? c : '_').ToArray());
     }
 
     public static string ToCamelCase(this string name)
     {
-        if (string.IsNullOrEmpty(name))
+        if (String.IsNullOrEmpty(name))
             return String.Empty;
 
-        return char.ToLower(name[0]) + name.Substring(1);
+        return Char.ToLower(name[0]) + name.Substring(1);
     }
 }
diff --git a/tests/Foundatio.Mediator.Tests/BasicHandlerGenerationTests.GeneratesWrapperForSimpleHandler.verified.txt b/tests/Foundatio.Mediator.Tests/BasicHandlerGenerationTests.GeneratesWrapperForSimpleHandler.verified.txt
@@ -110,27 +110,10 @@ internal static class PingHandler_Ping_Handler
         return HandlerScope.GetOrCreate(mediator, cancellationToken);
     }
 
-    private static PingHandler? _handler;
-    private static readonly global::System.Threading.Lock _lock = new();
-
     [DebuggerStepThrough]
     private static PingHandler GetOrCreateHandler(IServiceProvider serviceProvider)
     {
-        if (_handler != null)
-            return _handler;
-
-        var handlerFromDI = serviceProvider.GetService<PingHandler>();
-        if (handlerFromDI != null)
-            return handlerFromDI;
-
-        lock (_lock)
-        {
-            if (_handler != null)
-                return _handler;
-
-            _handler = ActivatorUtilities.CreateInstance<PingHandler>(serviceProvider);
-            return _handler;
-        }
+        return serviceProvider.GetRequiredService<PingHandler>();
     }
 }
 
@@ -145,6 +128,7 @@ internal static class PingHandler_Ping_Handler
 #nullable enable
 
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -162,8 +146,8 @@ public static class Tests_MediatorHandlers
     public static void AddHandlers(this IServiceCollection services)
     {
         // Register HandlerRegistration instances keyed by message type name
-        // Optionally register handler classes into DI based on MediatorHandlerLifetime setting
 
+        services.TryAddSingleton<PingHandler>();
         services.AddHandler(new HandlerRegistration(
                 MessageTypeKey.Get(typeof(Ping)),
                 "PingHandler_Ping_Handler",
diff --git a/tests/Foundatio.Mediator.Tests/GenericResultTests.cs b/tests/Foundatio.Mediator.Tests/GenericResultTests.cs
diff --git a/tests/Foundatio.Mediator.Tests/Integration/E2E_PublishAsyncTests.cs b/tests/Foundatio.Mediator.Tests/Integration/E2E_PublishAsyncTests.cs
diff --git a/tests/Foundatio.Mediator.Tests/Integration/ScopedDependencyTests.cs b/tests/Foundatio.Mediator.Tests/Integration/ScopedDependencyTests.cs

Original file line number	Diff line number	Diff line change
`@@ -3,19 +3,22 @@`
`3`	`3`	`using System.Text;`
`4`	`4`	`using Microsoft.Extensions.DependencyInjection;`
`5`	`5`	`using Microsoft.Extensions.Logging;`
	`6`	`+using Microsoft.Extensions.Logging.Abstractions;`
`6`	`7`
`7`	`8`	`namespace Foundatio.Mediator;`
`8`	`9`
`9`	`10`	`public class Mediator : IMediator, IServiceProvider`
`10`	`11`	`{`
`11`	`12`	`private readonly IServiceProvider _serviceProvider;`
`12`	`13`	`private readonly MediatorConfiguration _configuration;`
	`14`	`+ private readonly ILogger<Mediator> _logger;`
`13`	`15`
`14`	`16`	`[DebuggerStepThrough]`
`15`	`17`	`public Mediator(IServiceProvider serviceProvider, MediatorConfiguration? configuration = null)`
`16`	`18`	`{`
`17`	`19`	`_serviceProvider = serviceProvider;`
`18`	`20`	`_configuration = configuration ?? new MediatorConfiguration();`
	`21`	`+ _logger = _serviceProvider.GetService<ILogger<Mediator>>() ?? NullLogger<Mediator>.Instance;`
`19`	`22`	`}`
`20`	`23`
`21`	`24`	`public IServiceProvider ServiceProvider => _serviceProvider;`
`@@ -36,14 +39,14 @@ public void Invoke(object message, CancellationToken cancellationToken = default`
`36`	`39`	`public async ValueTask<TResponse> InvokeAsync<TResponse>(object message, CancellationToken cancellationToken = default)`
`37`	`40`	`{`
`38`	`41`	`var handlerFunc = GetInvokeAsyncResponseDelegate(message.GetType(), typeof(TResponse));`
`39`		`- var result = await handlerFunc(this, message, cancellationToken);`
	`42`	`+ object? result = await handlerFunc(this, message, cancellationToken);`
`40`	`43`	`return (TResponse)result!;`
`41`	`44`	`}`
`42`	`45`
`43`	`46`	`public TResponse Invoke<TResponse>(object message, CancellationToken cancellationToken = default)`
`44`	`47`	`{`
`45`	`48`	`var handlerFunc = GetInvokeResponseDelegate(message.GetType(), typeof(TResponse));`
`46`		`- var result = handlerFunc(this, message, cancellationToken);`
	`49`	`+ object? result = handlerFunc(this, message, cancellationToken);`
`47`	`50`	`return (TResponse)result!;`
`48`	`51`	`}`
`49`	`52`
`@@ -55,11 +58,10 @@ public ValueTask PublishAsync(object message, CancellationToken cancellationToke`
`55`	`58`
`56`	`59`	`public void ShowRegisteredHandlers()`
`57`	`60`	`{`
`58`		`- var logger = _serviceProvider.GetRequiredService<ILogger<Mediator>>();`
`59`	`61`	`var registrations = _serviceProvider.GetServices<HandlerRegistration>().ToArray();`
`60`	`62`	`if (!registrations.Any())`
`61`	`63`	`{`
`62`		`- logger.LogInformation("No handlers registered.");`
	`64`	`+ _logger.LogInformation("No handlers registered.");`
`63`	`65`	`return;`
`64`	`66`	`}`
`65`	`67`
`@@ -70,7 +72,7 @@ public void ShowRegisteredHandlers()`
`70`	`72`	`sb.AppendLine($"- Message: {registration.MessageTypeName}, Handler: {registration.HandlerClassName}, IsAsync: {registration.IsAsync}");`
`71`	`73`	`}`
`72`	`74`
`73`		`- logger.LogInformation(sb.ToString());`
	`75`	`+ _logger.LogInformation(sb.ToString());`
`74`	`76`	`}`
`75`	`77`
`76`	`78`	`[DebuggerStepThrough]`
`@@ -225,13 +227,13 @@ private IEnumerable<HandlerRegistration> GetHandlersForType(Type type)`
`225`	`227`	`public static T GetOrCreateMiddleware<T>(IServiceProvider serviceProvider) where T : class`
`226`	`228`	`{`
`227`	`229`	`// Check cache first - if it's there, it means it's not registered in DI`
`228`		`- if (_middlewareCache.TryGetValue(typeof(T), out var cachedInstance))`
	`230`	`+ if (_middlewareCache.TryGetValue(typeof(T), out object? cachedInstance))`
`229`	`231`	`return (T)cachedInstance;`
`230`	`232`
`231`	`233`	`// Try to get from DI - if registered, always use DI (respects service lifetime)`
`232`		`- var middlewareFromDI = serviceProvider.GetService<T>();`
`233`		`- if (middlewareFromDI != null)`
`234`		`- return middlewareFromDI;`
	`234`	`+ var middleware = serviceProvider.GetService<T>();`
	`235`	`+ if (middleware != null)`
	`236`	`+ return middleware;`
`235`	`237`
`236`	`238`	`// Not in DI, create and cache our own instance`
`237`	`239`	`return (T)_middlewareCache.GetOrAdd(typeof(T), type =>`
`@@ -263,9 +265,9 @@ public static T GetOrCreateMiddleware<T>(IServiceProvider serviceProvider) where`
`263`	`265`	`if (asyncMethod == null)`
`264`	`266`	`return null;`
`265`	`267`
`266`		`- HandleAsyncDelegate asyncDelegate = (IMediator mediator, object message, CancellationToken ct, Type? returnType) =>`
	`268`	`+ HandleAsyncDelegate asyncDelegate = (mediator, message, ct, returnType) =>`
`267`	`269`	`{`
`268`		`- var taskObj = asyncMethod.Invoke(null, new object?[] { mediator, message, ct, returnType });`
	`270`	`+ object? taskObj = asyncMethod.Invoke(null, [mediator, message, ct, returnType]);`
`269`	`271`	`return taskObj is ValueTask<object?> vt ? vt : (ValueTask<object?>)taskObj!;`
`270`	`272`	`};`
`271`	`273`
`@@ -275,10 +277,7 @@ public static T GetOrCreateMiddleware<T>(IServiceProvider serviceProvider) where`
`275`	`277`	`var syncMethod = wrapperClosed.GetMethod("UntypedHandle", System.Reflection.BindingFlags.Public \| System.Reflection.BindingFlags.Static);`
`276`	`278`	`if (syncMethod != null)`
`277`	`279`	`{`
`278`		`- syncDelegate = (IMediator mediator, object message, CancellationToken ct, Type? returnType) =>`
`279`		`- {`
`280`		`- return syncMethod.Invoke(null, new object?[] { mediator, message, ct, returnType });`
`281`		`- };`
	`280`	`+ syncDelegate = (mediator, message, ct, returnType) => syncMethod.Invoke(null, [mediator, message, ct, returnType]);`
`282`	`281`	`}`
`283`	`282`	`}`
`284`	`283`
Original file line number	Diff line number	Diff line change
`@@ -131,12 +131,12 @@ public static List<HandlerInfo> GetHandlers(GeneratorSyntaxContext context)`
`131`	`131`	`if (classSymbol.IsGenericType)`
`132`	`132`	`{`
`133`	`133`	`genericParamNames = classSymbol.TypeParameters.Select(tp => tp.Name).ToArray();`
`134`		`- genericConstraints = classSymbol.TypeParameters.Select(tp => BuildConstraintClause(tp)).Where(s => s.Length > 0).ToArray();`
	`134`	`+ genericConstraints = classSymbol.TypeParameters.Select(BuildConstraintClause).Where(s => s.Length > 0).ToArray();`
`135`	`135`	`}`
`136`	`136`	`else`
`137`	`137`	`{`
`138`		`- genericParamNames = Array.Empty<string>();`
`139`		`- genericConstraints = Array.Empty<string>();`
	`138`	`+ genericParamNames = [];`
	`139`	`+ genericConstraints = [];`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`handlers.Add(new HandlerInfo`
`@@ -198,7 +198,7 @@ private static IEnumerable<IMethodSymbol> GetMethods(INamedTypeSymbol targetSymb`
`198`	`198`
`199`	`199`	`foreach (var methodSymbol in methodSymbols)`
`200`	`200`	`{`
`201`		`- var signature = BuildMethodSignature(methodSymbol);`
	`201`	`+ string signature = BuildMethodSignature(methodSymbol);`
`202`	`202`
`203`	`203`	`if (!methods.ContainsKey(signature))`
`204`	`204`	`methods.Add(signature, methodSymbol);`
`@@ -218,11 +218,11 @@ private static string BuildMethodSignature(IMethodSymbol method)`
`218`	`218`	`if (method.Parameters.Length == 0)`
`219`	`219`	`return method.Name + "()";`
`220`	`220`
`221`		`- var parts = new string[method.Parameters.Length];`
	`221`	`+ string[] parts = new string[method.Parameters.Length];`
`222`	`222`	`for (int i = 0; i < method.Parameters.Length; i++)`
`223`	`223`	`parts[i] = method.Parameters[i].Type.ToDisplayString();`
`224`	`224`
`225`		`- return method.Name + "(" + string.Join(",", parts) + ")";`
	`225`	`+ return method.Name + "(" + String.Join(",", parts) + ")";`
`226`	`226`	`}`
`227`	`227`
`228`	`228`	`private static readonly string[] ValidHandlerMethodNames = [`
`@@ -234,7 +234,6 @@ private static string BuildMethodSignature(IMethodSymbol method)`
`234`	`234`
`235`	`235`	`private static string BuildConstraintClause(ITypeParameterSymbol tp)`
`236`	`236`	`{`
`237`		`- // Order: class/struct/unmanaged first, then specific constraint types, then notnull, then new()`
`238`	`237`	`var ordered = new List<string>();`
`239`	`238`
`240`	`239`	`if (tp.HasReferenceTypeConstraint)`
`@@ -246,8 +245,7 @@ private static string BuildConstraintClause(ITypeParameterSymbol tp)`
`246`	`245`
`247`	`246`	`foreach (var c in tp.ConstraintTypes)`
`248`	`247`	`{`
`249`		`- var display = c.ToDisplayString();`
`250`		`- // Avoid duplicating if already implicitly covered (rare, but defensive)`
	`248`	`+ string display = c.ToDisplayString();`
`251`	`249`	`if (!ordered.Contains(display))`
`252`	`250`	`ordered.Add(display);`
`253`	`251`	`}`
`@@ -258,8 +256,8 @@ private static string BuildConstraintClause(ITypeParameterSymbol tp)`
`258`	`256`	`ordered.Add("new()");`
`259`	`257`
`260`	`258`	`if (ordered.Count == 0)`
`261`		`- return string.Empty;`
	`259`	`+ return String.Empty;`
`262`	`260`
`263`		`- return $"where {tp.Name} : {string.Join(", ", ordered)}";`
	`261`	`+ return $"where {tp.Name} : {String.Join(", ", ordered)}";`
`264`	`262`	`}`
`265`	`263`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,17 +37,17 @@ private static string GetToolVersion()`
`37`	`37`
`38`	`38`	`public static string ToIdentifier(this string name)`
`39`	`39`	`{`
`40`		`- if (string.IsNullOrEmpty(name))`
	`40`	`+ if (String.IsNullOrEmpty(name))`
`41`	`41`	`return String.Empty;`
`42`	`42`
`43`		`- return new String(name.Select(c => char.IsLetterOrDigit(c) \|\| c == '_' ? c : '_').ToArray());`
	`43`	`+ return new string(name.Select(c => Char.IsLetterOrDigit(c) \|\| c == '_' ? c : '_').ToArray());`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`public static string ToCamelCase(this string name)`
`47`	`47`	`{`
`48`		`- if (string.IsNullOrEmpty(name))`
	`48`	`+ if (String.IsNullOrEmpty(name))`
`49`	`49`	`return String.Empty;`
`50`	`50`
`51`		`- return char.ToLower(name[0]) + name.Substring(1);`
	`51`	`+ return Char.ToLower(name[0]) + name.Substring(1);`
`52`	`52`	`}`
`53`	`53`	`}`