com.wallstop-studios.dxmessaging 2.0.0-rc06 → 2.0.0-rc07

package/Runtime/Core/MessageRegistrationToken.cs

@@ -6,7 +6,7 @@
     using Messages;
 
     /// <summary>
-    /// Maintains all of the [de]registration logic for MessagingComponents. Wraps registrations up for lazy registration, which are executed on Enable() call.
+    /// Maintains all the [de]registration logic for MessagingComponents. Wraps registrations up for lazy registration, which are executed on Enable() call.
     /// </summary>
     /// <note>
     /// General usage should be to create one of these on awake or start (probably start), and bind all messaging functions there.
@@ -27,27 +27,53 @@
         private MessageRegistrationToken(MessageHandler messageHandler, IMessageBus messageBus)
         {
             _enabled = false;
-            _messageHandler = messageHandler ?? throw new ArgumentNullException(nameof(messageHandler));
+            _messageHandler =
+                messageHandler ?? throw new ArgumentNullException(nameof(messageHandler));
             _messageBus = messageBus;
         }
 
-        private MessageRegistrationHandle RegisterTargetedInternal<T>(InstanceId target, Action<T> targetedHandler)
+        private MessageRegistrationHandle RegisterTargetedInternal<T>(
+            InstanceId target,
+            Action<T> targetedHandler,
+            int priority = 0
+        )
             where T : ITargetedMessage
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(targetedHandler, () => _messageHandler.RegisterTargetedMessageHandler(target, targetedHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterTargetedMessageHandler(
+                        target,
+                        targetedHandler,
+                        priority: priority,
+                        messageBus: _messageBus
+                    )
+            );
         }
 
-        private MessageRegistrationHandle RegisterTargetedInternal<T>(InstanceId target, MessageHandler.FastHandler<T> targetedHandler) where T : ITargetedMessage
+        private MessageRegistrationHandle RegisterTargetedInternal<T>(
+            InstanceId target,
+            MessageHandler.FastHandler<T> targetedHandler,
+            int priority = 0
+        )
+            where T : ITargetedMessage
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(targetedHandler, () => _messageHandler.RegisterTargetedMessageHandler(target, targetedHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterTargetedMessageHandler(
+                        target,
+                        targetedHandler,
+                        priority: priority,
+                        messageBus: _messageBus
+                    )
+            );
         }
 
 #if UNITY_2017_1_OR_NEWER
@@ -60,11 +86,16 @@
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="target">Target of the TargetedMessages to consume.</param>
         /// <param name="targetedHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterGameObjectTargeted<T>(UnityEngine.GameObject target, Action<T> targetedHandler)
+        public MessageRegistrationHandle RegisterGameObjectTargeted<T>(
+            UnityEngine.GameObject target,
+            Action<T> targetedHandler,
+            int priority = 0
+        )
             where T : ITargetedMessage
         {
-            return RegisterTargetedInternal(target, targetedHandler);
+            return RegisterTargetedInternal(target, targetedHandler, priority: priority);
         }
 
         /// <summary>
@@ -76,11 +107,16 @@
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="target">Target of the TargetedMessages to consume.</param>
         /// <param name="targetedHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterGameObjectTargeted<T>(UnityEngine.GameObject target, MessageHandler.FastHandler<T> targetedHandler)
+        public MessageRegistrationHandle RegisterGameObjectTargeted<T>(
+            UnityEngine.GameObject target,
+            MessageHandler.FastHandler<T> targetedHandler,
+            int priority = 0
+        )
             where T : ITargetedMessage
         {
-            return RegisterTargetedInternal(target, targetedHandler);
+            return RegisterTargetedInternal(target, targetedHandler, priority: priority);
         }
 
         /// <summary>
@@ -92,11 +128,16 @@
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="target">Target of the TargetedMessages to consume.</param>
         /// <param name="targetedHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterComponentTargeted<T>(UnityEngine.Component target, Action<T> targetedHandler)
+        public MessageRegistrationHandle RegisterComponentTargeted<T>(
+            UnityEngine.Component target,
+            Action<T> targetedHandler,
+            int priority = 0
+        )
             where T : ITargetedMessage
         {
-            return RegisterTargetedInternal(target, targetedHandler);
+            return RegisterTargetedInternal(target, targetedHandler, priority: priority);
         }
 
         /// <summary>
@@ -108,11 +149,16 @@
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="target">Target of the TargetedMessages to consume.</param>
         /// <param name="targetedHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterComponentTargeted<T>(UnityEngine.Component target, MessageHandler.FastHandler<T> targetedHandler)
+        public MessageRegistrationHandle RegisterComponentTargeted<T>(
+            UnityEngine.Component target,
+            MessageHandler.FastHandler<T> targetedHandler,
+            int priority = 0
+        )
             where T : ITargetedMessage
         {
-            return RegisterTargetedInternal(target, targetedHandler);
+            return RegisterTargetedInternal(target, targetedHandler, priority: priority);
         }
 
         /// <summary>
@@ -121,11 +167,24 @@
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="target">Target to post process messages for.</param>
         /// <param name="targetedPostProcessor">Actual post processor functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
         public MessageRegistrationHandle RegisterGameObjectTargetedPostProcessor<T>(
-            UnityEngine.GameObject target, MessageHandler.FastHandler<T> targetedPostProcessor) where T : ITargetedMessage
+            UnityEngine.GameObject target,
+            MessageHandler.FastHandler<T> targetedPostProcessor,
+            int priority = 0
+        )
+            where T : ITargetedMessage
         {
-            return InternalRegister(targetedPostProcessor, () => _messageHandler.RegisterTargetedPostProcessor(target, targetedPostProcessor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterTargetedPostProcessor(
+                        target,
+                        targetedPostProcessor,
+                        priority,
+                        _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -134,13 +193,27 @@
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="target">Target to post process messages for.</param>
         /// <param name="targetedPostProcessor">Actual post processor functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
         public MessageRegistrationHandle RegisterComponentTargetedPostProcessor<T>(
-            UnityEngine.Component target, MessageHandler.FastHandler<T> targetedPostProcessor) where T : ITargetedMessage
+            UnityEngine.Component target,
+            MessageHandler.FastHandler<T> targetedPostProcessor,
+            int priority = 0
+        )
+            where T : ITargetedMessage
         {
-            return InternalRegister(targetedPostProcessor, () => _messageHandler.RegisterTargetedPostProcessor(target, targetedPostProcessor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterTargetedPostProcessor(
+                        target,
+                        targetedPostProcessor,
+                        priority,
+                        _messageBus
+                    )
+            );
         }
 #else
+
         /// <summary>
         /// Stages a registration of the provided MessageHandler to accept TargetedMessages of the given type targeted towards the provided target.
         /// </summary>
@@ -150,11 +223,16 @@
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="target">Target of the TargetedMessages to consume.</param>
         /// <param name="targetedHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterTargeted<T>(InstanceId target, Action<T> targetedHandler)
+        public MessageRegistrationHandle RegisterTargeted<T>(
+            InstanceId target,
+            Action<T> targetedHandler,
+            int priority = 0
+        )
             where T : ITargetedMessage
         {
-            return RegisterTargetedInternal(target, targetedHandler);
+            return RegisterTargetedInternal(target, targetedHandler, priority: priority);
         }
 
         /// <summary>
@@ -166,11 +244,16 @@
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="target">Target of the TargetedMessages to consume.</param>
         /// <param name="targetedHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterTargeted<T>(InstanceId target, MessageHandler.FastHandler<T> targetedHandler)
+        public MessageRegistrationHandle RegisterTargeted<T>(
+            InstanceId target,
+            MessageHandler.FastHandler<T> targetedHandler,
+            int priority = 0
+        )
             where T : ITargetedMessage
         {
-            return RegisterTargetedInternal(target, targetedHandler);
+            return RegisterTargetedInternal(target, targetedHandler, priority: priority);
         }
 
         /// <summary>
@@ -179,11 +262,24 @@
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="target">Target to post process messages for.</param>
         /// <param name="targetedPostProcessor">Actual post processor functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
         public MessageRegistrationHandle RegisterTargetedPostProcessor<T>(
-            InstanceId target, MessageHandler.FastHandler<T> targetedPostProcessor) where T : ITargetedMessage
+            InstanceId target,
+            MessageHandler.FastHandler<T> targetedPostProcessor,
+            int priority = 0
+        )
+            where T : ITargetedMessage
         {
-            return InternalRegister(targetedPostProcessor, () => _messageHandler.RegisterTargetedPostProcessor(target, targetedPostProcessor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterTargetedPostProcessor(
+                        target,
+                        targetedPostProcessor,
+                        priority,
+                        _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -192,11 +288,24 @@
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="target">Target to post process messages for.</param>
         /// <param name="targetedPostProcessor">Actual post processor functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
         public MessageRegistrationHandle RegisterTargetedPostProcessor<T>(
-            InstanceId target, Action<T> targetedPostProcessor) where T : ITargetedMessage
+            InstanceId target,
+            Action<T> targetedPostProcessor,
+            int priority = 0
+        )
+            where T : ITargetedMessage
         {
-            return InternalRegister(targetedPostProcessor, () => _messageHandler.RegisterTargetedPostProcessor(target, targetedPostProcessor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterTargetedPostProcessor(
+                        target,
+                        targetedPostProcessor,
+                        priority,
+                        _messageBus
+                    )
+            );
         }
 #endif
 
@@ -208,14 +317,26 @@
         /// </note>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="messageHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterTargetedWithoutTargeting<T>(Action<InstanceId, T> messageHandler) where T : ITargetedMessage
+        public MessageRegistrationHandle RegisterTargetedWithoutTargeting<T>(
+            Action<InstanceId, T> messageHandler,
+            int priority = 0
+        )
+            where T : ITargetedMessage
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(messageHandler, () => _messageHandler.RegisterTargetedWithoutTargeting(messageHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterTargetedWithoutTargeting(
+                        messageHandler,
+                        priority: priority,
+                        messageBus: _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -226,14 +347,26 @@
         /// </note>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="messageHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterTargetedWithoutTargeting<T>(MessageHandler.FastHandlerWithContext<T> messageHandler) where T : ITargetedMessage
+        public MessageRegistrationHandle RegisterTargetedWithoutTargeting<T>(
+            MessageHandler.FastHandlerWithContext<T> messageHandler,
+            int priority = 0
+        )
+            where T : ITargetedMessage
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(messageHandler, () => _messageHandler.RegisterTargetedWithoutTargeting(messageHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterTargetedWithoutTargeting(
+                        messageHandler,
+                        priority: priority,
+                        messageBus: _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -244,14 +377,26 @@
         /// </note>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="postProcessor">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterTargetedWithoutTargetingPostProcessor<T>(Action<InstanceId, T> postProcessor) where T : ITargetedMessage
+        public MessageRegistrationHandle RegisterTargetedWithoutTargetingPostProcessor<T>(
+            Action<InstanceId, T> postProcessor,
+            int priority = 0
+        )
+            where T : ITargetedMessage
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(postProcessor, () => _messageHandler.RegisterTargetedWithoutTargetingPostProcessor(postProcessor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterTargetedWithoutTargetingPostProcessor(
+                        postProcessor,
+                        priority,
+                        _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -262,14 +407,26 @@
         /// </note>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="postProcessor">Actual post processor functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterTargetedWithoutTargetingPostProcessor<T>(MessageHandler.FastHandlerWithContext<T> postProcessor) where T : ITargetedMessage
+        public MessageRegistrationHandle RegisterTargetedWithoutTargetingPostProcessor<T>(
+            MessageHandler.FastHandlerWithContext<T> postProcessor,
+            int priority = 0
+        )
+            where T : ITargetedMessage
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(postProcessor, () => _messageHandler.RegisterTargetedWithoutTargetingPostProcessor(postProcessor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterTargetedWithoutTargetingPostProcessor(
+                        postProcessor,
+                        priority,
+                        _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -280,14 +437,26 @@
         /// </note>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="untargetedHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterUntargeted<T>(Action<T> untargetedHandler) where T : IUntargetedMessage
+        public MessageRegistrationHandle RegisterUntargeted<T>(
+            Action<T> untargetedHandler,
+            int priority = 0
+        )
+            where T : IUntargetedMessage
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(untargetedHandler, () => _messageHandler.RegisterUntargetedMessageHandler(untargetedHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterUntargetedMessageHandler(
+                        untargetedHandler,
+                        priority: priority,
+                        messageBus: _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -298,14 +467,26 @@
         /// </note>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="untargetedHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterUntargeted<T>(MessageHandler.FastHandler<T> untargetedHandler) where T : IUntargetedMessage
+        public MessageRegistrationHandle RegisterUntargeted<T>(
+            MessageHandler.FastHandler<T> untargetedHandler,
+            int priority = 0
+        )
+            where T : IUntargetedMessage
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(untargetedHandler, () => _messageHandler.RegisterUntargetedMessageHandler(untargetedHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterUntargetedMessageHandler(
+                        untargetedHandler,
+                        priority: priority,
+                        messageBus: _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -313,52 +494,114 @@
         /// </summary>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="untargetedPostProcessor">Actual post processor functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterUntargetedPostProcessor<T>(MessageHandler.FastHandler<T> untargetedPostProcessor) where T : IUntargetedMessage
+        public MessageRegistrationHandle RegisterUntargetedPostProcessor<T>(
+            MessageHandler.FastHandler<T> untargetedPostProcessor,
+            int priority = 0
+        )
+            where T : IUntargetedMessage
         {
             if (_messageHandler == null)
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(untargetedPostProcessor, () => _messageHandler.RegisterUntargetedPostProcessor(untargetedPostProcessor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterUntargetedPostProcessor(
+                        untargetedPostProcessor,
+                        priority,
+                        _messageBus
+                    )
+            );
         }
 
-        private MessageRegistrationHandle RegisterBroadcastInternal<T>(InstanceId source, Action<T> broadcastHandler) where T : IBroadcastMessage
+        private MessageRegistrationHandle RegisterBroadcastInternal<T>(
+            InstanceId source,
+            Action<T> broadcastHandler,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(broadcastHandler, () => _messageHandler.RegisterSourcedBroadcastMessageHandler(source, broadcastHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterSourcedBroadcastMessageHandler(
+                        source,
+                        broadcastHandler,
+                        priority: priority,
+                        messageBus: _messageBus
+                    )
+            );
         }
 
-        private MessageRegistrationHandle RegisterBroadcastInternal<T>(InstanceId source, MessageHandler.FastHandler<T> broadcastHandler) where T : IBroadcastMessage
+        private MessageRegistrationHandle RegisterBroadcastInternal<T>(
+            InstanceId source,
+            MessageHandler.FastHandler<T> broadcastHandler,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(broadcastHandler, () => _messageHandler.RegisterSourcedBroadcastMessageHandler(source, broadcastHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterSourcedBroadcastMessageHandler(
+                        source,
+                        broadcastHandler,
+                        priority: priority,
+                        messageBus: _messageBus
+                    )
+            );
         }
 
-        private MessageRegistrationHandle RegisterBroadcastPostProcessorInternal<T>(InstanceId source, Action<T> broadcastPostProcessor)
+        private MessageRegistrationHandle RegisterBroadcastPostProcessorInternal<T>(
+            InstanceId source,
+            Action<T> broadcastPostProcessor,
+            int priority
+        )
             where T : IBroadcastMessage
         {
             if (_messageHandler == null)
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(broadcastPostProcessor, () => _messageHandler.RegisterSourcedBroadcastPostProcessor(source, broadcastPostProcessor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterSourcedBroadcastPostProcessor(
+                        source,
+                        broadcastPostProcessor,
+                        priority,
+                        _messageBus
+                    )
+            );
         }
 
-        private MessageRegistrationHandle RegisterBroadcastPostProcessorInternal<T>(InstanceId source, MessageHandler.FastHandler<T> broadcastPostProcessor)
+        private MessageRegistrationHandle RegisterBroadcastPostProcessorInternal<T>(
+            InstanceId source,
+            MessageHandler.FastHandler<T> broadcastPostProcessor,
+            int priority
+        )
             where T : IBroadcastMessage
         {
             if (_messageHandler == null)
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(broadcastPostProcessor, () => _messageHandler.RegisterSourcedBroadcastPostProcessor(source, broadcastPostProcessor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterSourcedBroadcastPostProcessor(
+                        source,
+                        broadcastPostProcessor,
+                        priority,
+                        _messageBus
+                    )
+            );
         }
 
 #if UNITY_2017_1_OR_NEWER
@@ -371,10 +614,16 @@
         /// <typeparam name="T">Type of the message that the handler accepts.</typeparam>
         /// <param name="source">Id of the source for BroadcastMessages to listen for.</param>
         /// <param name="broadcastHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterGameObjectBroadcast<T>(UnityEngine.GameObject source, Action<T> broadcastHandler) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterGameObjectBroadcast<T>(
+            UnityEngine.GameObject source,
+            Action<T> broadcastHandler,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
-            return RegisterBroadcastInternal(source, broadcastHandler);
+            return RegisterBroadcastInternal(source, broadcastHandler, priority: priority);
         }
 
         /// <summary>
@@ -386,10 +635,16 @@
         /// <typeparam name="T">Type of the message that the handler accepts.</typeparam>
         /// <param name="source">Id of the source for BroadcastMessages to listen for.</param>
         /// <param name="broadcastHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterGameObjectBroadcast<T>(UnityEngine.GameObject source, MessageHandler.FastHandler<T> broadcastHandler) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterGameObjectBroadcast<T>(
+            UnityEngine.GameObject source,
+            MessageHandler.FastHandler<T> broadcastHandler,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
-            return RegisterBroadcastInternal(source, broadcastHandler);
+            return RegisterBroadcastInternal(source, broadcastHandler, priority: priority);
         }
 
         /// <summary>
@@ -397,11 +652,17 @@
         /// </summary>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="source">Source of the messages.</param>
-        /// <param name="broadcastPostProcesor">Actual post processor logic.</param>
+        /// <param name="broadcastPostProcessor">Actual post processor logic.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterGameObjectBroadcastPostProcessor<T>(UnityEngine.GameObject source, Action<T> broadcastPostProcesor) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterGameObjectBroadcastPostProcessor<T>(
+            UnityEngine.GameObject source,
+            Action<T> broadcastPostProcessor,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
-            return RegisterBroadcastPostProcessorInternal(source, broadcastPostProcesor);
+            return RegisterBroadcastPostProcessorInternal(source, broadcastPostProcessor, priority);
         }
 
         /// <summary>
@@ -409,11 +670,17 @@
         /// </summary>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="source">Source of the messages.</param>
-        /// <param name="broadcastPostProcesor">Actual post processor logic.</param>
+        /// <param name="broadcastPostProcessor">Actual post processor logic.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterGameObjectBroadcastPostProcessor<T>(UnityEngine.GameObject source, MessageHandler.FastHandler<T> broadcastPostProcesor) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterGameObjectBroadcastPostProcessor<T>(
+            UnityEngine.GameObject source,
+            MessageHandler.FastHandler<T> broadcastPostProcessor,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
-            return RegisterBroadcastPostProcessorInternal(source, broadcastPostProcesor);
+            return RegisterBroadcastPostProcessorInternal(source, broadcastPostProcessor, priority);
         }
 
         /// <summary>
@@ -425,10 +692,16 @@
         /// <typeparam name="T">Type of the message that the handler accepts.</typeparam>
         /// <param name="source">The component source for BroadcastMessages to listen for.</param>
         /// <param name="broadcastHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterComponentBroadcast<T>(UnityEngine.Component source, Action<T> broadcastHandler) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterComponentBroadcast<T>(
+            UnityEngine.Component source,
+            Action<T> broadcastHandler,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
-            return RegisterBroadcastInternal(source, broadcastHandler);
+            return RegisterBroadcastInternal(source, broadcastHandler, priority);
         }
 
         /// <summary>
@@ -440,10 +713,16 @@
         /// <typeparam name="T">Type of the message that the handler accepts.</typeparam>
         /// <param name="source">The component source for BroadcastMessages to listen for.</param>
         /// <param name="broadcastHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterComponentBroadcast<T>(UnityEngine.Component source, MessageHandler.FastHandler<T> broadcastHandler) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterComponentBroadcast<T>(
+            UnityEngine.Component source,
+            MessageHandler.FastHandler<T> broadcastHandler,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
-            return RegisterBroadcastInternal(source, broadcastHandler);
+            return RegisterBroadcastInternal(source, broadcastHandler, priority);
         }
 
         /// <summary>
@@ -451,33 +730,62 @@
         /// </summary>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="source">Source of the messages.</param>
-        /// <param name="broadcastPostProcesor">Actual post processor logic.</param>
+        /// <param name="broadcastPostProcessor">Actual post processor logic.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterComponentBroadcastPostProcessor<T>(UnityEngine.Component source, Action<T> broadcastPostProcesor) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterComponentBroadcastPostProcessor<T>(
+            UnityEngine.Component source,
+            Action<T> broadcastPostProcessor,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
             if (_messageHandler == null)
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(broadcastPostProcesor, () => _messageHandler.RegisterSourcedBroadcastPostProcessor(source, broadcastPostProcesor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterSourcedBroadcastPostProcessor(
+                        source,
+                        broadcastPostProcessor,
+                        priority: priority,
+                        _messageBus
+                    )
+            );
         }
-        
+
         /// <summary>
         /// Stages a registration of the provided PostProcessor to post process BroadcastMessages of the given type for the given component.
         /// </summary>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="source">Source of the messages.</param>
-        /// <param name="broadcastPostProcesor">Actual post processor logic.</param>
+        /// <param name="broadcastPostProcessor">Actual post processor logic.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterComponentBroadcastPostProcessor<T>(UnityEngine.Component source, MessageHandler.FastHandler<T> broadcastPostProcesor) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterComponentBroadcastPostProcessor<T>(
+            UnityEngine.Component source,
+            MessageHandler.FastHandler<T> broadcastPostProcessor,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
             if (_messageHandler == null)
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister(broadcastPostProcesor, () => _messageHandler.RegisterSourcedBroadcastPostProcessor(source, broadcastPostProcesor, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterSourcedBroadcastPostProcessor(
+                        source,
+                        broadcastPostProcessor,
+                        priority: priority,
+                        _messageBus
+                    )
+            );
         }
 #else
+
         /// <summary>
         /// Stages a registration of the provided MessageHandler to accept BroadcastMessages of the given type.
         /// </summary>
@@ -487,10 +795,16 @@
         /// <typeparam name="T">Type of the message that the handler accepts.</typeparam>
         /// <param name="source">Source of the messages.</param>
         /// <param name="broadcastHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterBroadcast<T>(InstanceId source, Action<T> broadcastHandler) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterBroadcast<T>(
+            InstanceId source,
+            Action<T> broadcastHandler,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
-            return RegisterBroadcastInternal(source, broadcastHandler);
+            return RegisterBroadcastInternal(source, broadcastHandler, priority: priority);
         }
 
         /// <summary>
@@ -502,10 +816,16 @@
         /// <typeparam name="T">Type of the message that the handler accepts.</typeparam>
         /// <param name="source">Source of the messages.</param>
         /// <param name="broadcastHandler">Actual handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterBroadcast<T>(InstanceId source, MessageHandler.FastHandler<T> broadcastHandler) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterBroadcast<T>(
+            InstanceId source,
+            MessageHandler.FastHandler<T> broadcastHandler,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
-            return RegisterBroadcastInternal(source, broadcastHandler);
+            return RegisterBroadcastInternal(source, broadcastHandler, priority: priority);
         }
 
         /// <summary>
@@ -513,11 +833,17 @@
         /// </summary>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="source">Source of the messages.</param>
-        /// <param name="broadcastPostProcesor">Actual post processor logic.</param>
+        /// <param name="broadcastPostProcessor">Actual post processor logic.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterBroadcastPostProcessor<T>(InstanceId source, Action<T> broadcastPostProcesor) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterBroadcastPostProcessor<T>(
+            InstanceId source,
+            Action<T> broadcastPostProcessor,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
-            return RegisterBroadcastPostProcessorInternal(source, broadcastPostProcesor);
+            return RegisterBroadcastPostProcessorInternal(source, broadcastPostProcessor, priority);
         }
 
         /// <summary>
@@ -525,11 +851,17 @@
         /// </summary>
         /// <typeparam name="T">Type of message that the handler accepts.</typeparam>
         /// <param name="source">Source of the messages.</param>
-        /// <param name="broadcastPostProcesor">Actual post processor logic.</param>
+        /// <param name="broadcastPostProcessor">Actual post processor logic.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterBroadcastPostProcessor<T>(InstanceId source, MessageHandler.FastHandler<T> broadcastPostProcesor) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterBroadcastPostProcessor<T>(
+            InstanceId source,
+            MessageHandler.FastHandler<T> broadcastPostProcessor,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
-            return RegisterBroadcastPostProcessorInternal(source, broadcastPostProcesor);
+            return RegisterBroadcastPostProcessorInternal(source, broadcastPostProcessor, priority);
         }
 #endif
 
@@ -541,8 +873,12 @@
         /// </note>
         /// <typeparam name="T">Type of the message that the handler accepts.</typeparam>
         /// <param name="broadcastHandler">Action handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterBroadcastWithoutSource<T>(Action<InstanceId, T> broadcastHandler)
+        public MessageRegistrationHandle RegisterBroadcastWithoutSource<T>(
+            Action<InstanceId, T> broadcastHandler,
+            int priority = 0
+        )
             where T : IBroadcastMessage
         {
             if (_messageHandler == null) // Unity has a bug
@@ -550,7 +886,14 @@
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
 
-            return InternalRegister(broadcastHandler, () => _messageHandler.RegisterSourcedBroadcastWithoutSource(broadcastHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterSourcedBroadcastWithoutSource(
+                        broadcastHandler,
+                        priority: priority,
+                        messageBus: _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -561,8 +904,12 @@
         /// </note>
         /// <typeparam name="T">Type of the message that the handler accepts.</typeparam>
         /// <param name="broadcastHandler">Action handler functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterBroadcastWithoutSource<T>(MessageHandler.FastHandlerWithContext<T> broadcastHandler)
+        public MessageRegistrationHandle RegisterBroadcastWithoutSource<T>(
+            MessageHandler.FastHandlerWithContext<T> broadcastHandler,
+            int priority = 0
+        )
             where T : IBroadcastMessage
         {
             if (_messageHandler == null) // Unity has a bug
@@ -570,7 +917,14 @@
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
 
-            return InternalRegister(broadcastHandler, () => _messageHandler.RegisterSourcedBroadcastWithoutSource(broadcastHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterSourcedBroadcastWithoutSource(
+                        broadcastHandler,
+                        priority: priority,
+                        messageBus: _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -581,8 +935,12 @@
         /// </note>
         /// <typeparam name="T">Type of the message that the handler accepts.</typeparam>
         /// <param name="broadcastHandler">Actual post process functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterBroadcastWithoutSourcePostProcessor<T>(Action<InstanceId, T> broadcastHandler)
+        public MessageRegistrationHandle RegisterBroadcastWithoutSourcePostProcessor<T>(
+            Action<InstanceId, T> broadcastHandler,
+            int priority = 0
+        )
             where T : IBroadcastMessage
         {
             if (_messageHandler == null) // Unity has a bug
@@ -590,7 +948,14 @@
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
 
-            return InternalRegister(broadcastHandler, () => _messageHandler.RegisterSourcedBroadcastWithoutSourcePostProcessor(broadcastHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterSourcedBroadcastWithoutSourcePostProcessor(
+                        broadcastHandler,
+                        priority: priority,
+                        _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -601,8 +966,12 @@
         /// </note>
         /// <typeparam name="T">Type of the message that the handler accepts.</typeparam>
         /// <param name="broadcastHandler">Actual post process functionality.</param>
+        /// <param name="priority">Priority at which to run the handler, lower runs earlier than higher.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterBroadcastWithoutSourcePostProcessor<T>(MessageHandler.FastHandlerWithContext<T> broadcastHandler)
+        public MessageRegistrationHandle RegisterBroadcastWithoutSourcePostProcessor<T>(
+            MessageHandler.FastHandlerWithContext<T> broadcastHandler,
+            int priority = 0
+        )
             where T : IBroadcastMessage
         {
             if (_messageHandler == null) // Unity has a bug
@@ -610,10 +979,16 @@
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
 
-            return InternalRegister(broadcastHandler, () => _messageHandler.RegisterSourcedBroadcastWithoutSourcePostProcessor(broadcastHandler, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterSourcedBroadcastWithoutSourcePostProcessor(
+                        broadcastHandler,
+                        priority: priority,
+                        _messageBus
+                    )
+            );
         }
 
-
         /// <summary>
         /// Stages a registration of the provided MessageHandler to accept every message that is broadcast.
         /// </summary>
@@ -624,13 +999,25 @@
         /// <param name="acceptAllTargeted">Action handler functionality for TargetedMessages.</param>
         /// <param name="acceptAllBroadcast">Action handler functionality for BroadcastMessages.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterGlobalAcceptAll(Action<IUntargetedMessage> acceptAllUntargeted, Action<InstanceId, ITargetedMessage> acceptAllTargeted, Action<InstanceId, IBroadcastMessage> acceptAllBroadcast)
+        public MessageRegistrationHandle RegisterGlobalAcceptAll(
+            Action<IUntargetedMessage> acceptAllUntargeted,
+            Action<InstanceId, ITargetedMessage> acceptAllTargeted,
+            Action<InstanceId, IBroadcastMessage> acceptAllBroadcast
+        )
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister<IMessage>(() => _messageHandler.RegisterGlobalAcceptAll(acceptAllUntargeted, acceptAllTargeted, acceptAllBroadcast, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterGlobalAcceptAll(
+                        acceptAllUntargeted,
+                        acceptAllTargeted,
+                        acceptAllBroadcast,
+                        _messageBus
+                    )
+            );
         }
 
         /// <summary>
@@ -643,130 +1030,96 @@
         /// <param name="acceptAllTargeted">Action handler functionality for TargetedMessages.</param>
         /// <param name="acceptAllBroadcast">Action handler functionality for BroadcastMessages.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        public MessageRegistrationHandle RegisterGlobalAcceptAll(MessageHandler.FastHandler<IUntargetedMessage> acceptAllUntargeted, MessageHandler.FastHandlerWithContext<ITargetedMessage> acceptAllTargeted, MessageHandler.FastHandlerWithContext<IBroadcastMessage> acceptAllBroadcast)
+        public MessageRegistrationHandle RegisterGlobalAcceptAll(
+            MessageHandler.FastHandler<IUntargetedMessage> acceptAllUntargeted,
+            MessageHandler.FastHandlerWithContext<ITargetedMessage> acceptAllTargeted,
+            MessageHandler.FastHandlerWithContext<IBroadcastMessage> acceptAllBroadcast
+        )
         {
             if (_messageHandler == null) // Unity has a bug
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
-            return InternalRegister<IMessage>(() => _messageHandler.RegisterGlobalAcceptAll(acceptAllUntargeted, acceptAllTargeted, acceptAllBroadcast, _messageBus));
+            return InternalRegister(
+                () =>
+                    _messageHandler.RegisterGlobalAcceptAll(
+                        acceptAllUntargeted,
+                        acceptAllTargeted,
+                        acceptAllBroadcast,
+                        _messageBus
+                    )
+            );
         }
 
-        public MessageRegistrationHandle RegisterUntargetedInterceptor<T>(IMessageBus.UntargetedInterceptor<T> interceptor, int priority = 0) where T : IUntargetedMessage
+        public MessageRegistrationHandle RegisterUntargetedInterceptor<T>(
+            IMessageBus.UntargetedInterceptor<T> interceptor,
+            int priority = 0
+        )
+            where T : IUntargetedMessage
         {
             if (_messageHandler == null)
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
 
-            return InternalRegister<T>(() => _messageHandler.RegisterUntargetedInterceptor(interceptor, priority));
+            return InternalRegister(
+                () => _messageHandler.RegisterUntargetedInterceptor(interceptor, priority)
+            );
         }
 
-        public MessageRegistrationHandle RegisterBroadcastInterceptor<T>(IMessageBus.BroadcastInterceptor<T> interceptor, int priority = 0) where T : IBroadcastMessage
+        public MessageRegistrationHandle RegisterBroadcastInterceptor<T>(
+            IMessageBus.BroadcastInterceptor<T> interceptor,
+            int priority = 0
+        )
+            where T : IBroadcastMessage
         {
             if (_messageHandler == null)
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
 
-            return InternalRegister<T>(() => _messageHandler.RegisterBroadcastInterceptor(interceptor, priority));
+            return InternalRegister(
+                () => _messageHandler.RegisterBroadcastInterceptor(interceptor, priority)
+            );
         }
 
-        public MessageRegistrationHandle RegisterTargetedInterceptor<T>(IMessageBus.TargetedInterceptor<T> interceptor, int priority = 0) where T : ITargetedMessage
+        public MessageRegistrationHandle RegisterTargetedInterceptor<T>(
+            IMessageBus.TargetedInterceptor<T> interceptor,
+            int priority = 0
+        )
+            where T : ITargetedMessage
         {
             if (_messageHandler == null)
             {
                 return MessageRegistrationHandle.CreateMessageRegistrationHandle();
             }
 
-            return InternalRegister<T>(() => _messageHandler.RegisterTargetedInterceptor(interceptor, priority));
-        }
-
-        /// <summary>
-        /// Handles the actual [de]registration wrapping and (potential) lazy execution.
-        /// </summary>
-        /// <typeparam name="T">Type of message being registered.</typeparam>
-        /// <param name="handler">Handler being registered (mainly used for type info).</param>
-        /// <param name="registerAndGetDeregistration">Proxied registration function that returns a de-registration function.</param>
-        /// <returns>A handle that allows for registration and de-registration.</returns>
-        // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
-        private MessageRegistrationHandle InternalRegister<T>(Action<T> handler, Func<Action> registerAndGetDeregistration)
-            where T : IMessage
-        {
-            if (handler == null)
-            {
-                throw new ArgumentNullException(nameof(handler));
-            }
-
-            return InternalRegister<T>(registerAndGetDeregistration);
-        }
-
-        /// <summary>
-        /// Handles the actual [de]registration wrapping and (potential) lazy execution.
-        /// </summary>
-        /// <typeparam name="T">Type of message being registered.</typeparam>
-        /// <param name="handler">Handler being registered (mainly used for type info).</param>
-        /// <param name="registerAndGetDeregistration">Proxied registration function that returns a de-registration function.</param>
-        /// <returns>A handle that allows for registration and de-registration.</returns>
-        // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
-        private MessageRegistrationHandle InternalRegister<T>(Action<InstanceId, T> handler, Func<Action> registerAndGetDeregistration)
-            where T : IMessage
-        {
-            if (handler == null)
-            {
-                throw new ArgumentNullException(nameof(handler));
-            }
-
-            return InternalRegister<T>(registerAndGetDeregistration);
+            return InternalRegister(
+                () => _messageHandler.RegisterTargetedInterceptor(interceptor, priority)
+            );
         }
 
         /// <summary>
         /// Handles the actual [de]registration wrapping and (potential) lazy execution.
         /// </summary>
-        /// <typeparam name="T">Type of message being registered.</typeparam>
-        /// <param name="handler">Handler being registered (mainly used for type info).</param>
         /// <param name="registerAndGetDeregistration">Proxied registration function that returns a de-registration function.</param>
         /// <returns>A handle that allows for registration and de-registration.</returns>
-        // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
-        private MessageRegistrationHandle InternalRegister<T>(MessageHandler.FastHandler<T> handler, Func<Action> registerAndGetDeregistration)
-            where T : IMessage
+        private MessageRegistrationHandle InternalRegister(
+            Func<Action> registerAndGetDeregistration
+        )
         {
-            if (handler == null)
-            {
-                throw new ArgumentNullException(nameof(handler));
-            }
+            MessageRegistrationHandle handle =
+                MessageRegistrationHandle.CreateMessageRegistrationHandle();
 
-            return InternalRegister<T>(registerAndGetDeregistration);
-        }
+            _registrations[handle] = Registration;
 
-        /// <summary>
-        /// Handles the actual [de]registration wrapping and (potential) lazy execution.
-        /// </summary>
-        /// <typeparam name="T">Type of message being registered.</typeparam>
-        /// <param name="handler">Handler being registered (mainly used for type info).</param>
-        /// <param name="registerAndGetDeregistration">Proxied registration function that returns a de-registration function.</param>
-        /// <returns>A handle that allows for registration and de-registration.</returns>
-        // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
-        private MessageRegistrationHandle InternalRegister<T>(MessageHandler.FastHandlerWithContext<T> handler, Func<Action> registerAndGetDeregistration)
-            where T : IMessage
-        {
-            if (handler == null)
+            // Generally, registrations should take place before all calls to enable. Just in case, though...
+            if (_enabled)
             {
-                throw new ArgumentNullException(nameof(handler));
+                Registration();
             }
 
-            return InternalRegister<T>(registerAndGetDeregistration);
-        }
-
-        /// <summary>
-        /// Handles the actual [de]registration wrapping and (potential) lazy execution.
-        /// </summary>
-        /// <typeparam name="T">Type of message being registered.</typeparam>
-        /// <param name="registerAndGetDeregistration">Proxied registration function that returns a de-registration function.</param>
-        /// <returns>A handle that allows for registration and de-registration.</returns>
-        private MessageRegistrationHandle InternalRegister<T>(Func<Action> registerAndGetDeregistration)
-        {
-            MessageRegistrationHandle handle = MessageRegistrationHandle.CreateMessageRegistrationHandle();
+            return handle;
 
             // We don't want to actually register at this time (might not be awake/enabled) - so we wrap that shit up, to lazy register when we're enabled.
             void Registration()
@@ -774,16 +1127,6 @@
                 Action actualDeregistration = registerAndGetDeregistration();
                 _deregistrations[handle] = actualDeregistration;
             }
-
-            _registrations[handle] = Registration;
-
-            // Generally, registrations should take place before all calls to enable. Just in case, though...
-            if (_enabled)
-            {
-                Registration();
-            }
-
-            return handle;
         }
 
         /// <summary>
@@ -832,7 +1175,7 @@
             }
 
             // ReSharper disable once ForCanBeConvertedToForeach
-            
+
 
             _enabled = false;
         }
@@ -857,7 +1200,10 @@
 
         public void RemoveRegistration(MessageRegistrationHandle handle)
         {
-            if (_deregistrations != null && _deregistrations.TryGetValue(handle, out Action deregistrationAction))
+            if (
+                _deregistrations != null
+                && _deregistrations.TryGetValue(handle, out Action deregistrationAction)
+            )
             {
                 deregistrationAction();
                 _ = _deregistrations.Remove(handle);
@@ -872,7 +1218,10 @@
         /// <param name="messageHandler">Message handler to register handlers to.</param>
         /// <param name="messageBus">MessageBus to use for this MessageRegistrationToken. Uses the GlobalMessageBus if left null.</param>
         /// <returns>MessagingRegistrationToken bound to the MessageHandler.</returns>
-        public static MessageRegistrationToken Create(MessageHandler messageHandler, IMessageBus messageBus = null)
+        public static MessageRegistrationToken Create(
+            MessageHandler messageHandler,
+            IMessageBus messageBus = null
+        )
         {
             if (messageHandler == null)
             {