Explicit AddHandler registration API (#7439)

* Add IHandleMessages and config extension

* Make RegisterHandler generic

* Move IsMessageHandler

* Don't deprecate RegisterHandler(Type) with error, use reflection to call generic

* Remove separate timeout handler registration method

* Replace GetMessageTypesBeingHandledBy implementation with more efficient one that doesn't use MakeGenericType (which is not AOT friendly)

* Bring the generics further down

* Change runtime check for injecting IMessageSession into compile-time analyzer

* Handler creation is ugly but might work

* Error in nullability test was excluding types with get-only properties that did have nullability enabled

* Not needed due to the new analyzer

* Can have IHandleMessages & IHandleTimeouts of same type

* Registration of both handler and timeout only when necessary, using reflection but I don't think anything AOT-averse

* Also not needed due to new analyzer

* This is wrong, this is done at a level up - at this level it could be both timeout/handler

* Parameterless IHandleTimeouts doesn't need to exist with the updated implementation

* RegisterHandler interceptor

* Made the first stage very memoizable

* Memoizable at all 3 levels

* Ability to output stage results

* Create method name from stable hash of file path + source span

* Generator test will automatically account for platform-unique data on interceptor attributes

* Remove test for unsupported handler registration in container

* Hash only handler type and dedupe calls

* Change RegisterHandler to AddHandler

* See if we can achieve something different

* Strong typing through

* Simplify

* Deprecate the removed MessageHandler constructor with error

* Easier to read without one inverted, and must be able to register for Handle and Timeout

* Fix tests

* Split add methods for handler and timeout with stronger generic constraints

* Fix interceptor with longer method name

* Add saga to interceptor test

* Just messing with the spacing/indent in the tests

* Fix after rebase

* Approve

* Variable naming

* Sealing

* Variable naming

* Sealed

* Rename to factories for now

* Cleanup test

* Add multi interface test

* Correctly cache factory for now

* Faster casting

* Dedup

* Add additional test

* Fix and use slight redundancy for better clarity

* Use built-in API

* Move handler related stuff

* Use non-cryptographic hash

* Fix spacin

* Cleanup

* InterceptDetails is too large to be a struct

* Simplify generator

* Remove leftover struct

* Remove using

* Stable ordering of method names

* Specify types explicitely to avoid nullable ref types

* Fast path first

* Simplify slightly

* Switch to symbol based analysis (#7483)

* Switch to symbol based analysis

* Static delegate

* No need for generics

* Use GetTypeSymbolOrDefault

* Be more defensive and avoid closure

* Inline directly

* Cleanup using

---------

Co-authored-by: Daniel Marbach <danielmarbach@users.noreply.github.com>

* Extracing non-cryptographic hash that will be useful in other source generators as well

* Span based

* For loop

* Manual unrolling and unsafe

BenchmarkDotNet v0.13.8, macOS 26.1 (25B78) [Darwin 25.1.0]
Apple M4 Max, 1 CPU, 16 logical and 16 physical cores
.NET SDK 10.0.100
  [Host]     : .NET 10.0.0 (10.0.25.52411), Arm64 RyuJIT AdvSIMD
  DefaultJob : .NET 10.0.0 (10.0.25.52411), Arm64 RyuJIT AdvSIMD

| Method           | Mean     | Error     | StdDev    | Ratio | RatioSD | Allocated | Alloc Ratio |
|----------------- |---------:|----------:|----------:|------:|--------:|----------:|------------:|
| HashBaseline     | 8.429 ns | 0.1537 ns | 0.1438 ns |  1.00 |    0.00 |         - |          NA |
| HashUnroll       | 7.728 ns | 0.0663 ns | 0.0620 ns |  0.92 |    0.02 |         - |          NA |
| HashUnsafe       | 8.213 ns | 0.1716 ns | 0.1605 ns |  0.97 |    0.03 |         - |          NA |
| HashUnsafeUnroll | 7.311 ns | 0.0792 ns | 0.0702 ns |  0.87 |    0.02 |         - |          NA |

* Use AddHandler api to register handlers in ATTs (#7482)

* Use AddHandler api to register handlers in ATTs

* Test cleanup

* Fix conventions in test

* Test cleanup

* Use asm qualified name

* Test cleanup

* Naive fix to the handler ordering

* Test cleanup

* Register messages handled by the endpoint as messages

* Rollback unneded test change

* Rollback unneded test change

* Uneeded test change

* Cleanup

* Remove usings

* Use AddHandler to control handler ordering

* Revert handler registry changes

* Switch to add handler instead of ExecuteTheseHandlersFirst

* Initialize handler registry earlier

* Obsolete ExecuteTheseHandlersFirst with error

* Approvals

* Move diagnostic entry to a better place

* Cleanup test

* Test cleanup

* Remove handler detection code from the MessageMetadataRegistry

* Refactor

* Add test that ensures that we can types for messages

* Cleanup

* Add test that scans handlers

* Make message public

* Simplify

* Move obsoletes

---------

Co-authored-by: Daniel Marbach <daniel.marbach@openplace.net>
Co-authored-by: Daniel Marbach <danielmarbach@users.noreply.github.com>

* Fix after rebase

* Get rid of scanning in ATTs

* Cleanup att server

* Remove uneeded config

* Better test name

* Remove EditorBrowsable attributes on AddMessage/TimeoutHandlerForMessage methods

---------

Co-authored-by: Daniel Marbach <danielmarbach@users.noreply.github.com>
Co-authored-by: Andreas Öhlund <andreas.ohlund@particular.net>
Co-authored-by: Daniel Marbach <daniel.marbach@openplace.net>

Author: 3 people

src/NServiceBus.AcceptanceTesting/Customization/EndpointConfigurationExtensions.cs

@@ -4,6 +4,7 @@ namespace NServiceBus.AcceptanceTesting.Customization;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using Hosting.Helpers;
 using Sagas;
 using Support;
 
@@ -22,15 +23,25 @@ public static class EndpointConfigurationExtensions
     public static void ScanTypesForTest(this EndpointConfiguration config,
         EndpointCustomizationConfiguration customizationConfiguration)
     {
-        var typesToIncludeInScanning = GetNestedTypeRecursive(customizationConfiguration.BuilderType.DeclaringType, customizationConfiguration.BuilderType)
-            .Where(t => t.IsAssignableTo(typeof(IHandleMessages))
-                        || t.IsAssignableTo(typeof(IFinder))
+        var testTypes = GetNestedTypeRecursive(customizationConfiguration.BuilderType.DeclaringType, customizationConfiguration.BuilderType).ToList();
+
+        var typesToIncludeInScanning = testTypes
+            .Where(t => t.IsAssignableTo(typeof(IFinder))
                         || t.IsAssignableTo(typeof(IHandleSagaNotFound))
                         || t.IsAssignableTo(typeof(Saga)))
             .Union(customizationConfiguration.TypesToInclude);
 
         config.TypesToIncludeInScan(typesToIncludeInScanning);
 
+        //auto-register handlers for now
+        if (customizationConfiguration.AutoRegisterHandlers)
+        {
+            foreach (var messageHandler in testTypes.Where(t => t.IsAssignableTo(typeof(IHandleMessages))))
+            {
+                AddHandlerWithReflection(messageHandler, config);
+            }
+        }
+
         IEnumerable<Type> GetNestedTypeRecursive(Type rootType, Type builderType)
         {
             if (rootType == null)
@@ -77,4 +88,10 @@ public static void EnforcePublisherMetadataRegistration(this EndpointConfigurati
         config.Pipeline.Register(new EnforceSubscriptionPublisherMetadataBehavior(endpointName, publisherMetadata),
             "Enforces all subscribed events have corresponding mappings in the PublisherMetadata");
     }
+
+    static void AddHandlerWithReflection(Type handlerType, EndpointConfiguration endpointConfiguration) =>
+        typeof(MessageHandlerRegistrationExtensions)
+            .GetMethod("AddHandler", BindingFlags.Public | BindingFlags.Static)!
+            .MakeGenericMethod(handlerType)
+            .Invoke(null, [endpointConfiguration]);
 }

src/NServiceBus.AcceptanceTesting/EndpointConfigurationBuilder.cs

@@ -115,4 +115,11 @@ public EndpointConfigurationBuilder IncludeType<T>()
 
         return this;
     }
+
+    public EndpointConfigurationBuilder DoNotAutoRegisterHandlers()
+    {
+        configuration.AutoRegisterHandlers = false;
+
+        return this;
+    }
 }

src/NServiceBus.AcceptanceTesting/Support/EndpointCustomizationConfiguration.cs

@@ -25,4 +25,6 @@ public string EndpointName
     public string CustomEndpointName { get; set; }
 
     public bool DisableStartupDiagnostics { get; set; } = true;
+
+    public bool AutoRegisterHandlers { get; set; } = true;
 }

src/NServiceBus.AcceptanceTesting/Support/IEndpointSetupTemplate.cs

@@ -5,5 +5,5 @@
 
 public interface IEndpointSetupTemplate
 {
-    Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointConfiguration, Func<EndpointConfiguration, Task> configurationBuilderCustomization);
+    Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor, EndpointCustomizationConfiguration endpointCustomizationConfiguration, Func<EndpointConfiguration, Task> configurationBuilderCustomization);
 }

src/NServiceBus.AcceptanceTests/Core/BestPractices/When_injecting_message_session_into_handlers.cs

@@ -27,36 +27,21 @@ public class Context : ScenarioContext
 
     public class Sender : EndpointConfigurationBuilder
     {
-        public Sender()
-        {
-            EndpointSetup<DefaultServer>(c =>
-            {
-                c.ConfigureRouting().RouteToEndpoint(typeof(NonMatchingMessageWithHandler), typeof(Receiver));
-            });
-        }
+        public Sender() =>
+            EndpointSetup<DefaultServer>(c => c.ConfigureRouting().RouteToEndpoint(typeof(NonMatchingMessageWithHandler), typeof(Receiver)));
     }
 
     public class Receiver : EndpointConfigurationBuilder
     {
-        public Receiver()
-        {
-            EndpointSetup<DefaultServer>(c => c.Conventions().DefiningMessagesAs(t => false));
-        }
+        public Receiver() => EndpointSetup<DefaultServer>(c => c.Conventions().DefiningMessagesAs(t => false));
 
-        class MyHandler : IHandleMessages<NonMatchingMessageWithHandler>
+        class MyHandler(Context testContext) : IHandleMessages<NonMatchingMessageWithHandler>
         {
-            public MyHandler(Context context)
-            {
-                testContext = context;
-            }
-
             public Task Handle(NonMatchingMessageWithHandler message, IMessageHandlerContext context)
             {
                 testContext.GotTheMessage = true;
                 return Task.CompletedTask;
             }
-
-            readonly Context testContext;
         }
     }
 

src/NServiceBus.AcceptanceTests/Core/Conventions/When_receiving_non_matching_message_with_handler.cs

@@ -0,0 +1,45 @@
+namespace NServiceBus.AcceptanceTests.Core.Hosting;
+
+using System.Threading.Tasks;
+using AcceptanceTesting;
+using EndpointTemplates;
+using NUnit.Framework;
+
+public class When_scanning_is_enabled : NServiceBusAcceptanceTest
+{
+    [Test]
+    public async Task Should_discover_handlers()
+    {
+        var context = await Scenario.Define<Context>()
+            .WithEndpoint<MyEndpoint>(c => c
+                .When(b => b.SendLocal(new MyMessage())))
+            .Done(c => c.GotTheMessage)
+            .Run();
+
+        Assert.That(context.GotTheMessage, Is.True);
+    }
+
+    class Context : ScenarioContext
+    {
+        public bool GotTheMessage { get; set; }
+    }
+
+    class MyEndpoint : EndpointConfigurationBuilder
+    {
+        public MyEndpoint() =>
+            EndpointSetup<DefaultServer>()
+                .DoNotAutoRegisterHandlers()
+                .IncludeType<MyMessageHandler>();
+
+        public class MyMessageHandler(Context testContext) : IHandleMessages<MyMessage>
+        {
+            public Task Handle(MyMessage message, IMessageHandlerContext context)
+            {
+                testContext.GotTheMessage = true;
+                return Task.CompletedTask;
+            }
+        }
+    }
+
+    public class MyMessage : IMessage;
+}

src/NServiceBus.AcceptanceTests/Core/Hosting/When_scanning_is_enabled.cs

@@ -33,14 +33,12 @@ public class Context : ScenarioContext
 
     public class Endpoint : EndpointConfigurationBuilder
     {
-        public Endpoint()
-        {
+        public Endpoint() =>
             EndpointSetup<DefaultServer>(c =>
             {
                 c.UseSerialization<XmlSerializer>();
                 c.RegisterMessageMutator(new MyTransportMessageMutator());
             });
-        }
 
         class MyTransportMessageMutator : IMutateOutgoingTransportMessages
         {
@@ -53,22 +51,15 @@ public Task MutateOutgoing(MutateOutgoingTransportMessageContext context)
             }
         }
 
-        class MessageToBeMutatedHandler : IHandleMessages<MessageThatMutatorChangesTo>
+        class MessageToBeMutatedHandler(Context testContext) : IHandleMessages<MessageThatMutatorChangesTo>
         {
-            public MessageToBeMutatedHandler(Context testContext)
-            {
-                this.testContext = testContext;
-            }
-
             public Task Handle(MessageThatMutatorChangesTo message, IMessageHandlerContext context)
             {
                 testContext.CanAddHeaders = context.MessageHeaders.ContainsKey("HeaderSetByMutator");
                 testContext.MutatedPropertyValue = message.SomeProperty;
                 testContext.MessageProcessed = true;
                 return Task.CompletedTask;
             }
-
-            Context testContext;
         }
     }
 

src/NServiceBus.AcceptanceTests/Core/Mutators/When_using_outgoing_tm_mutator.cs

@@ -8,9 +8,9 @@
 public class OpenTelemetryEnabledEndpoint : DefaultServer
 {
     public override Task<EndpointConfiguration> GetConfiguration(RunDescriptor runDescriptor,
-        EndpointCustomizationConfiguration endpointConfiguration,
+        EndpointCustomizationConfiguration endpointCustomizationConfiguration,
         Func<EndpointConfiguration, Task> configurationBuilderCustomization) =>
-        base.GetConfiguration(runDescriptor, endpointConfiguration, configuration =>
+        base.GetConfiguration(runDescriptor, endpointCustomizationConfiguration, configuration =>
         {
             configuration.EnableOpenTelemetry();
             return configurationBuilderCustomization(configuration);

src/NServiceBus.AcceptanceTests/Core/OpenTelemetry/OpenTelemetryEnabledEndpoint.cs

@@ -28,24 +28,16 @@ public class Context : ScenarioContext
         public bool SecondHandlerInvoked { get; set; }
     }
 
-    public class SomeMessage : IMessage
-    {
-    }
-
     public class MyEndpoint : EndpointConfigurationBuilder
     {
-        public MyEndpoint()
+        public MyEndpoint() => EndpointSetup<DefaultServer>(c =>
         {
-            EndpointSetup<DefaultServer>(c => c.ExecuteTheseHandlersFirst(typeof(FirstHandler), typeof(SecondHandler)));
-        }
+            c.AddHandler<FirstHandler>();
+            c.AddHandler<SecondHandler>();
+        });
 
-        class FirstHandler : IHandleMessages<SomeMessage>
+        class FirstHandler(Context testContext) : IHandleMessages<SomeMessage>
         {
-            public FirstHandler(Context context)
-            {
-                testContext = context;
-            }
-
             public Task Handle(SomeMessage message, IMessageHandlerContext context)
             {
                 testContext.FirstHandlerInvoked = true;
@@ -54,27 +46,18 @@ public Task Handle(SomeMessage message, IMessageHandlerContext context)
 
                 return Task.CompletedTask;
             }
-
-            Context testContext;
-
         }
 
-        class SecondHandler : IHandleMessages<SomeMessage>
+        class SecondHandler(Context testContext) : IHandleMessages<SomeMessage>
         {
-            public SecondHandler(Context context)
-            {
-                testContext = context;
-            }
-
             public Task Handle(SomeMessage message, IMessageHandlerContext context)
             {
                 testContext.SecondHandlerInvoked = true;
 
                 return Task.CompletedTask;
             }
-
-            Context testContext;
-
         }
     }
+
+    public class SomeMessage : IMessage;
 }