Always process messages that have handlers regardless of conventions

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

@@ -0,0 +1,62 @@
+namespace NServiceBus.AcceptanceTests.Core.Conventions
+{
+    using System.Threading.Tasks;
+    using AcceptanceTesting;
+    using AcceptanceTesting.Customization;
+    using EndpointTemplates;
+    using NUnit.Framework;
+
+    public class When_receiving_non_matching_message_with_handler : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public async Task Should_process_message()
+        {
+            var context = await Scenario.Define<Context>()
+                .WithEndpoint<Sender>(c => c.When(s => s.Send(new NonMatchingMessageWithHandler())))
+                .WithEndpoint<Receiver>()
+                .Done(c => c.GotTheMessage)
+                .Run();
+
+            Assert.True(context.GotTheMessage);
+        }
+
+        public class Context : ScenarioContext
+        {
+            public bool GotTheMessage { get; set; }
+        }
+
+        public class Sender : EndpointConfigurationBuilder
+        {
+            public Sender()
+            {
+                EndpointSetup<DefaultServer>(c =>
+                {
+                    c.ConfigureTransport().Routing().RouteToEndpoint(typeof(NonMatchingMessageWithHandler), typeof(Receiver));
+                });
+            }
+        }
+
+        public class Receiver : EndpointConfigurationBuilder
+        {
+            public Receiver()
+            {
+                EndpointSetup<DefaultServer>(c => c.Conventions().DefiningMessagesAs(t => false));
+            }
+
+            class MyHandler : IHandleMessages<NonMatchingMessageWithHandler>
+            {
+                public Context TestContext { get; set; }
+
+                public Task Handle(NonMatchingMessageWithHandler message, IMessageHandlerContext context)
+                {
+                    TestContext.GotTheMessage = true;
+                    return Task.FromResult(0);
+                }
+            }
+        }
+
+        public class NonMatchingMessageWithHandler : IMessage
+        {
+        }
+    }
+}

src/NServiceBus.Core.Tests/Handlers/MessageHandlerRegistryTests.cs

@@ -18,15 +18,15 @@ public class MessageHandlerRegistryTests
         [TestCase(typeof(SagaWithIllegalDep))]
         public void ShouldThrowIfUserTriesToBypassTheHandlerContext(Type handlerType)
         {
-            var registry = new MessageHandlerRegistry(new Conventions());
+            var registry = new MessageHandlerRegistry();
 
             Assert.Throws<Exception>(() => registry.RegisterHandler(handlerType));
         }
 
         [Test]
         public async Task ShouldIndicateWhetherAHandlerIsATimeoutHandler()
         {
-            var registry = new MessageHandlerRegistry(new Conventions());
+            var registry = new MessageHandlerRegistry();
 
             registry.RegisterHandler(typeof(SagaWithTimeoutOfMessage));
 

src/NServiceBus.Core.Tests/Unicast/HandlerInvocationCache.cs

@@ -15,7 +15,7 @@ public class HandlerInvocationCachePerformanceTests
         [Test]
         public async Task RunNew()
         {
-            var cache = new MessageHandlerRegistry(new Conventions());
+            var cache = new MessageHandlerRegistry();
             cache.RegisterHandler(typeof(StubMessageHandler));
             cache.RegisterHandler(typeof(StubTimeoutHandler));
             var stubMessage = new StubMessage();
@@ -67,7 +67,7 @@ public class When_invoking_a_cached_message_handler
         [Test]
         public async Task Should_invoke_handle_method()
         {
-            var cache = new MessageHandlerRegistry(new Conventions());
+            var cache = new MessageHandlerRegistry();
             cache.RegisterHandler(typeof(StubHandler));
 
             var handler = cache.GetCachedHandlerForMessage<StubMessage>();
@@ -80,7 +80,7 @@ public async Task Should_invoke_handle_method()
         [Test]
         public async Task Should_have_passed_through_correct_message()
         {
-            var cache = new MessageHandlerRegistry(new Conventions());
+            var cache = new MessageHandlerRegistry();
             cache.RegisterHandler(typeof(StubHandler));
 
             var handler = cache.GetCachedHandlerForMessage<StubMessage>();
@@ -94,7 +94,7 @@ public async Task Should_have_passed_through_correct_message()
         [Test]
         public async Task Should_have_passed_through_correct_context()
         {
-            var cache = new MessageHandlerRegistry(new Conventions());
+            var cache = new MessageHandlerRegistry();
             cache.RegisterHandler(typeof(StubHandler));
 
             var handler = cache.GetCachedHandlerForMessage<StubMessage>();
@@ -130,7 +130,7 @@ public class When_invoking_a_cached_timeout_handler
         [Test]
         public async Task Should_invoke_timeout_method()
         {
-            var cache = new MessageHandlerRegistry(new Conventions());
+            var cache = new MessageHandlerRegistry();
             cache.RegisterHandler(typeof(StubHandler));
 
             var handler = cache.GetCachedHandlerForMessage<StubTimeoutState>();
@@ -143,7 +143,7 @@ public async Task Should_invoke_timeout_method()
         [Test]
         public async Task Should_have_passed_through_correct_state()
         {
-            var cache = new MessageHandlerRegistry(new Conventions());
+            var cache = new MessageHandlerRegistry();
             cache.RegisterHandler(typeof(StubHandler));
 
             var stubState = new StubTimeoutState();
@@ -157,7 +157,7 @@ public async Task Should_have_passed_through_correct_state()
         [Test]
         public async Task Should_have_passed_through_correct_context()
         {
-            var cache = new MessageHandlerRegistry(new Conventions());
+            var cache = new MessageHandlerRegistry();
             cache.RegisterHandler(typeof(StubHandler));
 
             var handler = cache.GetCachedHandlerForMessage<StubTimeoutState>();

src/NServiceBus.Core.Tests/Unicast/LoadHandlersBehaviorTests.cs

@@ -11,7 +11,7 @@ public class LoadHandlersBehaviorTests
         [Test]
         public void Should_throw_when_there_are_no_registered_message_handlers()
         {
-            var behavior = new LoadHandlersConnector(new MessageHandlerRegistry(new Conventions()), new InMemorySynchronizedStorage(), new InMemoryTransactionalSynchronizedStorageAdapter());
+            var behavior = new LoadHandlersConnector(new MessageHandlerRegistry(), new InMemorySynchronizedStorage(), new InMemoryTransactionalSynchronizedStorageAdapter());
 
             var context = new TestableIncomingLogicalMessageContext();
 

src/NServiceBus.Core/Unicast/Config/RegisterHandlersInOrder.cs

@@ -43,7 +43,7 @@ static void LoadMessageHandlers(FeatureConfigurationContext context, List<Type>
 
         static void ConfigureMessageHandlersIn(FeatureConfigurationContext context, IEnumerable<Type> types)
         {
-            var handlerRegistry = new MessageHandlerRegistry(context.Settings.Get<Conventions>());
+            var handlerRegistry = new MessageHandlerRegistry();
 
             foreach (var t in types.Where(IsMessageHandler))
             {

src/NServiceBus.Core/Unicast/MessageHandlerRegistry.cs

@@ -13,11 +13,6 @@
     /// </summary>
     public class MessageHandlerRegistry
     {
-        internal MessageHandlerRegistry(Conventions conventions)
-        {
-            this.conventions = conventions;
-        }
-
         /// <summary>
         /// Gets the list of handlers <see cref="Type" />s for the given
         /// <paramref name="messageType" />.
@@ -26,10 +21,6 @@ internal MessageHandlerRegistry(Conventions conventions)
         public List<MessageHandler> GetHandlersFor(Type messageType)
         {
             Guard.AgainstNull(nameof(messageType), messageType);
-            if (!conventions.IsMessageType(messageType))
-            {
-                return noMessageHandlers;
-            }
 
             var messageHandlers = new List<MessageHandler>();
             // ReSharper disable once LoopCanBeConvertedToQuery
@@ -60,7 +51,6 @@ public IEnumerable<Type> GetMessageTypes()
             return (from messagesBeingHandled in handlerAndMessagesHandledByHandlerCache.Values
                 from typeHandled in messagesBeingHandled
                 let messageType = typeHandled.MessageType
-                where conventions.IsMessageType(messageType)
                 select messageType).Distinct();
         }
 
@@ -181,9 +171,7 @@ void ValidateHandlerType(Type handlerType)
             }
         }
 
-        readonly Conventions conventions;
         readonly Dictionary<Type, List<DelegateHolder>> handlerAndMessagesHandledByHandlerCache = new Dictionary<Type, List<DelegateHolder>>();
-        static List<MessageHandler> noMessageHandlers = new List<MessageHandler>(0);
         static ILog Log = LogManager.GetLogger<MessageHandlerRegistry>();
 
         class DelegateHolder