Fix DI registration issue with multiple handlers in the same file

Author: ejsmith

src/Foundatio.Mediator/HandlerAnalyzer.cs

@@ -194,11 +194,15 @@ private static IEnumerable<IMethodSymbol> GetMethods(INamedTypeSymbol targetSymb
             var methodSymbols = currentSymbol
                 .GetMembers()
                 .Where(m => m.Kind == SymbolKind.Method)
-                .OfType<IMethodSymbol>()
-                .Where(p => !methods.ContainsKey(p.Name));
+                .OfType<IMethodSymbol>();
 
             foreach (var methodSymbol in methodSymbols)
-                methods.Add(methodSymbol.Name, methodSymbol);
+            {
+                var signature = BuildMethodSignature(methodSymbol);
+
+                if (!methods.ContainsKey(signature))
+                    methods.Add(signature, methodSymbol);
+            }
 
             if (!includeBaseMethods)
                 break;
@@ -209,6 +213,18 @@ private static IEnumerable<IMethodSymbol> GetMethods(INamedTypeSymbol targetSymb
         return methods.Values;
     }
 
+    private static string BuildMethodSignature(IMethodSymbol method)
+    {
+        if (method.Parameters.Length == 0)
+            return method.Name + "()";
+
+        var 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) + ")";
+    }
+
     private static readonly string[] ValidHandlerMethodNames = [
         "Handle", "HandleAsync",
         "Handles", "HandlesAsync",

tests/Foundatio.Mediator.Tests/DIRegistrationTests.cs

@@ -54,6 +54,30 @@ public class AHandler { public Task HandleAsync(A m, CancellationToken ct) => Ta
         Assert.DoesNotContain("AddTransient<AHandler>()", di.Source);
     }
 
+    [Fact]
+    public void Handles_MultipleMessages()
+    {
+        var src = """
+            using System.Threading;
+            using System.Threading.Tasks;
+            using Foundatio.Mediator;
+
+            public record A;
+            public record B;
+            public class MultiHandler {
+                public Task HandleAsync(A m, CancellationToken ct) => Task.CompletedTask;
+                public Task HandleAsync(B m, CancellationToken ct) => Task.CompletedTask;
+            }
+            """;
+
+        var (_, _, trees) = RunGenerator(src, [ new MediatorGenerator() ]);
+        var di = trees.First(t => t.HintName.EndsWith("_MediatorHandlers.g.cs"));
+        Assert.Contains("MessageTypeKey.Get(typeof(A))", di.Source);
+        Assert.Contains("MessageTypeKey.Get(typeof(B))", di.Source);
+        Assert.Contains("MultiHandler_A_Handler", di.Source);
+        Assert.Contains("MultiHandler_B_Handler", di.Source);
+    }
+
     [Theory]
     [InlineData("Transient", "AddTransient<AHandler>()")]
     [InlineData("Scoped", "AddScoped<AHandler>()")]