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

package/Runtime/Core/MessageBus/MessageBus.cs

@@ -81,8 +81,8 @@
         private readonly Stack<
             List<KeyValuePair<int, Dictionary<MessageHandler, int>>>
         > _sortedHandlers = new();
-        private readonly Stack<List<object>> _interceptors = new();
-        private readonly Stack<List<int>> _interceptorKeys = new();
+        private readonly Stack<List<List<object>>> _interceptors = new();
+        private readonly Stack<List<object>> _innerInterceptorsStack = new();
 
         public Action RegisterUntargeted<T>(MessageHandler messageHandler, int priority = 0)
             where T : IUntargetedMessage
@@ -394,12 +394,12 @@
                 bool complete = false;
                 if (removed)
                 {
-                    if (_interceptsByType.TryGetValue(type, out prioritizedInterceptors))
+                    if (
+                        _interceptsByType.TryGetValue(type, out prioritizedInterceptors)
+                        && prioritizedInterceptors.TryGetValue(priority, out interceptors)
+                    )
                     {
-                        if (prioritizedInterceptors.TryGetValue(priority, out interceptors))
-                        {
-                            complete = interceptors.Remove(interceptor);
-                        }
+                        complete = interceptors.Remove(interceptor);
                     }
 
                     if (!complete)
@@ -467,38 +467,29 @@
             )
             {
                 foundAnyHandlers = true;
-                List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
-                    GetOrAddMessageHandlerStack(sortedHandlers);
-                try
+                if (sortedHandlers.Count == 1)
                 {
-                    foreach (
-                        KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
-                    )
+                    KeyValuePair<int, Dictionary<MessageHandler, int>> entry =
+                        sortedHandlers.First();
+                    RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                }
+                else
+                {
+                    List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
+                        GetOrAddMessageHandlerStack(sortedHandlers);
+                    try
                     {
-                        int priority = entry.Key;
-                        List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                            entry.Value.Keys
-                        );
-                        try
-                        {
-                            foreach (MessageHandler handler in messageHandlers)
-                            {
-                                handler.HandleUntargetedPostProcessing(
-                                    ref typedMessage,
-                                    this,
-                                    priority
-                                );
-                            }
-                        }
-                        finally
+                        foreach (
+                            KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
+                        )
                         {
-                            _messageHandlers.Push(messageHandlers);
+                            RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
                         }
                     }
-                }
-                finally
-                {
-                    _sortedHandlers.Push(handlerList);
+                    finally
+                    {
+                        _sortedHandlers.Push(handlerList);
+                    }
                 }
             }
 
@@ -512,6 +503,51 @@
             }
         }
 
+        private void RunUntargetedPostProcessing<TMessage>(
+            ref TMessage typedMessage,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : IUntargetedMessage
+        {
+            switch (handlers.Count)
+            {
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = handlers.Keys.First();
+                    handler.HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    return;
+                }
+                default:
+                {
+                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
+                        handlers.Keys
+                    );
+                    try
+                    {
+                        foreach (MessageHandler handler in messageHandlers)
+                        {
+                            handler.HandleUntargetedPostProcessing(
+                                ref typedMessage,
+                                this,
+                                priority
+                            );
+                        }
+                    }
+                    finally
+                    {
+                        _messageHandlers.Push(messageHandlers);
+                    }
+
+                    break;
+                }
+            }
+        }
+
         public void UntypedTargetedBroadcast(InstanceId target, ITargetedMessage typedMessage)
         {
             Type messageType = typedMessage.MessageType;
@@ -572,39 +608,34 @@
             )
             {
                 foundAnyHandlers = true;
-                List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
-                    GetOrAddMessageHandlerStack(sortedHandlers);
-                try
+                if (sortedHandlers.Count == 1)
                 {
-                    foreach (
-                        KeyValuePair<int, Dictionary<MessageHandler, int>> handlers in handlerList
-                    )
+                    KeyValuePair<int, Dictionary<MessageHandler, int>> entry =
+                        sortedHandlers.First();
+                    RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                }
+                else
+                {
+                    List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
+                        GetOrAddMessageHandlerStack(sortedHandlers);
+                    try
                     {
-                        int priority = handlers.Key;
-                        List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                            handlers.Value.Keys
-                        );
-                        try
-                        {
-                            foreach (MessageHandler handler in messageHandlers)
-                            {
-                                handler.HandleTargeted(
-                                    ref target,
-                                    ref typedMessage,
-                                    this,
-                                    priority
-                                );
-                            }
-                        }
-                        finally
+                        foreach (
+                            KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
+                        )
                         {
-                            _messageHandlers.Push(messageHandlers);
+                            RunTargetedBroadcast(
+                                ref target,
+                                ref typedMessage,
+                                entry.Key,
+                                entry.Value
+                            );
                         }
                     }
-                }
-                finally
-                {
-                    _sortedHandlers.Push(handlerList);
+                    finally
+                    {
+                        _sortedHandlers.Push(handlerList);
+                    }
                 }
             }
 
@@ -617,39 +648,34 @@
             )
             {
                 foundAnyHandlers = true;
-                List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
-                    GetOrAddMessageHandlerStack(sortedHandlers);
-                try
+                if (sortedHandlers.Count == 1)
                 {
-                    foreach (
-                        KeyValuePair<int, Dictionary<MessageHandler, int>> handlers in handlerList
-                    )
+                    KeyValuePair<int, Dictionary<MessageHandler, int>> entry =
+                        sortedHandlers.First();
+                    RunTargetedPostProcessing(ref target, ref typedMessage, entry.Key, entry.Value);
+                }
+                else
+                {
+                    List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
+                        GetOrAddMessageHandlerStack(sortedHandlers);
+                    try
                     {
-                        int priority = handlers.Key;
-                        List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                            handlers.Value.Keys
-                        );
-                        try
-                        {
-                            foreach (MessageHandler handler in messageHandlers)
-                            {
-                                handler.HandleTargetedPostProcessing(
-                                    ref target,
-                                    ref typedMessage,
-                                    this,
-                                    priority
-                                );
-                            }
-                        }
-                        finally
+                        foreach (
+                            KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
+                        )
                         {
-                            _messageHandlers.Push(messageHandlers);
+                            RunTargetedPostProcessing(
+                                ref target,
+                                ref typedMessage,
+                                entry.Key,
+                                entry.Value
+                            );
                         }
                     }
-                }
-                finally
-                {
-                    _sortedHandlers.Push(handlerList);
+                    finally
+                    {
+                        _sortedHandlers.Push(handlerList);
+                    }
                 }
             }
 
@@ -658,39 +684,39 @@
                 && 0 < sortedHandlers.Count
             )
             {
-                List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
-                    GetOrAddMessageHandlerStack(sortedHandlers);
-                try
+                if (sortedHandlers.Count == 1)
                 {
-                    foreach (
-                        KeyValuePair<int, Dictionary<MessageHandler, int>> handlers in handlerList
-                    )
+                    KeyValuePair<int, Dictionary<MessageHandler, int>> entry =
+                        sortedHandlers.First();
+                    RunTargetedWithoutTargetingPostProcessing(
+                        ref target,
+                        ref typedMessage,
+                        entry.Key,
+                        entry.Value
+                    );
+                }
+                else
+                {
+                    List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
+                        GetOrAddMessageHandlerStack(sortedHandlers);
+                    try
                     {
-                        int priority = handlers.Key;
-                        List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                            handlers.Value.Keys
-                        );
-                        try
-                        {
-                            foreach (MessageHandler handler in messageHandlers)
-                            {
-                                handler.HandleTargetedWithoutTargetingPostProcessing(
-                                    ref target,
-                                    ref typedMessage,
-                                    this,
-                                    priority
-                                );
-                            }
-                        }
-                        finally
+                        foreach (
+                            KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
+                        )
                         {
-                            _messageHandlers.Push(messageHandlers);
+                            RunTargetedWithoutTargetingPostProcessing(
+                                ref target,
+                                ref typedMessage,
+                                entry.Key,
+                                entry.Value
+                            );
                         }
                     }
-                }
-                finally
-                {
-                    _sortedHandlers.Push(handlerList);
+                    finally
+                    {
+                        _sortedHandlers.Push(handlerList);
+                    }
                 }
             }
 
@@ -705,6 +731,152 @@
             }
         }
 
+        private void RunTargetedWithoutTargetingPostProcessing<TMessage>(
+            ref InstanceId target,
+            ref TMessage typedMessage,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : ITargetedMessage
+        {
+            switch (handlers.Count)
+            {
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = handlers.Keys.First();
+                    handler.HandleTargetedWithoutTargetingPostProcessing(
+                        ref target,
+                        ref typedMessage,
+                        this,
+                        priority
+                    );
+                    return;
+                }
+                default:
+                {
+                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
+                        handlers.Keys
+                    );
+                    try
+                    {
+                        foreach (MessageHandler handler in messageHandlers)
+                        {
+                            handler.HandleTargetedWithoutTargetingPostProcessing(
+                                ref target,
+                                ref typedMessage,
+                                this,
+                                priority
+                            );
+                        }
+                    }
+                    finally
+                    {
+                        _messageHandlers.Push(messageHandlers);
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        private void RunTargetedPostProcessing<TMessage>(
+            ref InstanceId target,
+            ref TMessage typedMessage,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : ITargetedMessage
+        {
+            switch (handlers.Count)
+            {
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = handlers.Keys.First();
+                    handler.HandleTargetedPostProcessing(
+                        ref target,
+                        ref typedMessage,
+                        this,
+                        priority
+                    );
+                    return;
+                }
+                default:
+                {
+                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
+                        handlers.Keys
+                    );
+                    try
+                    {
+                        foreach (MessageHandler handler in messageHandlers)
+                        {
+                            handler.HandleTargetedPostProcessing(
+                                ref target,
+                                ref typedMessage,
+                                this,
+                                priority
+                            );
+                        }
+                    }
+                    finally
+                    {
+                        _messageHandlers.Push(messageHandlers);
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        private void RunTargetedBroadcast<TMessage>(
+            ref InstanceId target,
+            ref TMessage typedMessage,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : ITargetedMessage
+        {
+            switch (handlers.Count)
+            {
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = handlers.Keys.First();
+                    handler.HandleTargeted(ref target, ref typedMessage, this, priority);
+                    return;
+                }
+                default:
+                {
+                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
+                        handlers.Keys
+                    );
+                    try
+                    {
+                        foreach (MessageHandler handler in messageHandlers)
+                        {
+                            handler.HandleTargeted(ref target, ref typedMessage, this, priority);
+                        }
+                    }
+                    finally
+                    {
+                        _messageHandlers.Push(messageHandlers);
+                    }
+
+                    break;
+                }
+            }
+        }
+
         public void UntypedSourcedBroadcast(InstanceId source, IBroadcastMessage typedMessage)
         {
             Type messageType = typedMessage.MessageType;
@@ -768,39 +940,29 @@
             )
             {
                 foundAnyHandlers = true;
-                List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
-                    GetOrAddMessageHandlerStack(sortedHandlers);
-                try
+                if (sortedHandlers.Count == 1)
                 {
-                    foreach (
-                        KeyValuePair<int, Dictionary<MessageHandler, int>> handlers in handlerList
-                    )
+                    KeyValuePair<int, Dictionary<MessageHandler, int>> entry =
+                        sortedHandlers.First();
+                    RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                }
+                else
+                {
+                    List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
+                        GetOrAddMessageHandlerStack(sortedHandlers);
+                    try
                     {
-                        int priority = handlers.Key;
-                        List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                            handlers.Value.Keys
-                        );
-                        try
-                        {
-                            foreach (MessageHandler handler in messageHandlers)
-                            {
-                                handler.HandleSourcedBroadcast(
-                                    ref source,
-                                    ref typedMessage,
-                                    this,
-                                    priority
-                                );
-                            }
-                        }
-                        finally
+                        foreach (
+                            KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
+                        )
                         {
-                            _messageHandlers.Push(messageHandlers);
+                            RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
                         }
                     }
-                }
-                finally
-                {
-                    _sortedHandlers.Push(handlerList);
+                    finally
+                    {
+                        _sortedHandlers.Push(handlerList);
+                    }
                 }
             }
 
@@ -813,39 +975,39 @@
             )
             {
                 foundAnyHandlers = true;
-                List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
-                    GetOrAddMessageHandlerStack(sortedHandlers);
-                try
+                if (sortedHandlers.Count == 1)
                 {
-                    foreach (
-                        KeyValuePair<int, Dictionary<MessageHandler, int>> handlers in handlerList
-                    )
+                    KeyValuePair<int, Dictionary<MessageHandler, int>> entry =
+                        sortedHandlers.First();
+                    RunBroadcastPostProcessing(
+                        ref source,
+                        ref typedMessage,
+                        entry.Key,
+                        entry.Value
+                    );
+                }
+                else
+                {
+                    List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
+                        GetOrAddMessageHandlerStack(sortedHandlers);
+                    try
                     {
-                        int priority = handlers.Key;
-                        List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                            handlers.Value.Keys
-                        );
-                        try
-                        {
-                            foreach (MessageHandler handler in messageHandlers)
-                            {
-                                handler.HandleSourcedBroadcastPostProcessing(
-                                    ref source,
-                                    ref typedMessage,
-                                    this,
-                                    priority
-                                );
-                            }
-                        }
-                        finally
+                        foreach (
+                            KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
+                        )
                         {
-                            _messageHandlers.Push(messageHandlers);
+                            RunBroadcastPostProcessing(
+                                ref source,
+                                ref typedMessage,
+                                entry.Key,
+                                entry.Value
+                            );
                         }
                     }
-                }
-                finally
-                {
-                    _sortedHandlers.Push(handlerList);
+                    finally
+                    {
+                        _sortedHandlers.Push(handlerList);
+                    }
                 }
             }
 
@@ -854,39 +1016,39 @@
                 && 0 < sortedHandlers.Count
             )
             {
-                List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
-                    GetOrAddMessageHandlerStack(sortedHandlers);
-                try
+                if (sortedHandlers.Count == 1)
                 {
-                    foreach (
-                        KeyValuePair<int, Dictionary<MessageHandler, int>> handlers in handlerList
-                    )
+                    KeyValuePair<int, Dictionary<MessageHandler, int>> entry =
+                        sortedHandlers.First();
+                    RunBroadcastWithoutSourcePostProcessing(
+                        ref source,
+                        ref typedMessage,
+                        entry.Key,
+                        entry.Value
+                    );
+                }
+                else
+                {
+                    List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
+                        GetOrAddMessageHandlerStack(sortedHandlers);
+                    try
                     {
-                        int priority = handlers.Key;
-                        List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                            handlers.Value.Keys
-                        );
-                        try
-                        {
-                            foreach (MessageHandler handler in messageHandlers)
-                            {
-                                handler.HandleSourcedBroadcastWithoutSourcePostProcessing(
-                                    ref source,
-                                    ref typedMessage,
-                                    this,
-                                    priority
-                                );
-                            }
-                        }
-                        finally
+                        foreach (
+                            KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
+                        )
                         {
-                            _messageHandlers.Push(messageHandlers);
+                            RunBroadcastWithoutSourcePostProcessing(
+                                ref source,
+                                ref typedMessage,
+                                entry.Key,
+                                entry.Value
+                            );
                         }
                     }
-                }
-                finally
-                {
-                    _sortedHandlers.Push(handlerList);
+                    finally
+                    {
+                        _sortedHandlers.Push(handlerList);
+                    }
                 }
             }
 
@@ -901,94 +1063,304 @@
             }
         }
 
-        private void BroadcastGlobalUntargeted(ref IUntargetedMessage message)
+        private void RunBroadcastWithoutSourcePostProcessing<TMessage>(
+            ref InstanceId source,
+            ref TMessage typedMessage,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : IBroadcastMessage
         {
-            if (_globalSinks.Count <= 0)
-            {
-                return;
-            }
-
-            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(_globalSinks.Keys);
-            try
+            switch (handlers.Count)
             {
-                foreach (MessageHandler handler in messageHandlers)
+                case <= 0:
                 {
-                    handler.HandleGlobalUntargetedMessage(ref message, this);
+                    return;
                 }
-            }
-            finally
-            {
-                _messageHandlers.Push(messageHandlers);
-            }
-        }
-
-        private void BroadcastGlobalTargeted(ref InstanceId target, ref ITargetedMessage message)
-        {
-            if (_globalSinks.Count <= 0)
-            {
-                return;
-            }
-
-            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(_globalSinks.Keys);
-            try
-            {
-                foreach (MessageHandler handler in messageHandlers)
+                case 1:
                 {
-                    handler.HandleGlobalTargetedMessage(ref target, ref message, this);
+                    MessageHandler handler = handlers.Keys.First();
+                    handler.HandleSourcedBroadcastWithoutSourcePostProcessing(
+                        ref source,
+                        ref typedMessage,
+                        this,
+                        priority
+                    );
+                    return;
+                }
+                default:
+                {
+                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
+                        handlers.Keys
+                    );
+                    try
+                    {
+                        foreach (MessageHandler handler in messageHandlers)
+                        {
+                            handler.HandleSourcedBroadcastWithoutSourcePostProcessing(
+                                ref source,
+                                ref typedMessage,
+                                this,
+                                priority
+                            );
+                        }
+                    }
+                    finally
+                    {
+                        _messageHandlers.Push(messageHandlers);
+                    }
+
+                    break;
                 }
             }
-            finally
+        }
+
+        private void RunBroadcastPostProcessing<TMessage>(
+            ref InstanceId source,
+            ref TMessage typedMessage,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : IBroadcastMessage
+        {
+            switch (handlers.Count)
             {
-                _messageHandlers.Push(messageHandlers);
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = handlers.Keys.First();
+                    handler.HandleSourcedBroadcastPostProcessing(
+                        ref source,
+                        ref typedMessage,
+                        this,
+                        priority
+                    );
+                    return;
+                }
+                default:
+                {
+                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
+                        handlers.Keys
+                    );
+                    try
+                    {
+                        foreach (MessageHandler handler in messageHandlers)
+                        {
+                            handler.HandleSourcedBroadcastPostProcessing(
+                                ref source,
+                                ref typedMessage,
+                                this,
+                                priority
+                            );
+                        }
+                    }
+                    finally
+                    {
+                        _messageHandlers.Push(messageHandlers);
+                    }
+
+                    break;
+                }
             }
         }
 
-        private void BroadcastGlobalSourcedBroadcast(
+        private void RunBroadcast<TMessage>(
             ref InstanceId source,
-            ref IBroadcastMessage message
+            ref TMessage typedMessage,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
         )
+            where TMessage : IBroadcastMessage
         {
-            if (_globalSinks.Count <= 0)
+            switch (handlers.Count)
             {
-                return;
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = handlers.Keys.First();
+                    handler.HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    return;
+                }
+                default:
+                {
+                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
+                        handlers.Keys
+                    );
+                    try
+                    {
+                        foreach (MessageHandler handler in messageHandlers)
+                        {
+                            handler.HandleSourcedBroadcast(
+                                ref source,
+                                ref typedMessage,
+                                this,
+                                priority
+                            );
+                        }
+                    }
+                    finally
+                    {
+                        _messageHandlers.Push(messageHandlers);
+                    }
+
+                    break;
+                }
             }
+        }
 
-            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(_globalSinks.Keys);
-            try
+        private void BroadcastGlobalUntargeted(ref IUntargetedMessage message)
+        {
+            switch (_globalSinks.Count)
             {
-                foreach (MessageHandler handler in messageHandlers)
+                case <= 0:
                 {
-                    handler.HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = _globalSinks.Keys.First();
+                    handler.HandleGlobalUntargetedMessage(ref message, this);
+                    return;
+                }
+                default:
+                {
+                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
+                        _globalSinks.Keys
+                    );
+                    try
+                    {
+                        foreach (MessageHandler handler in messageHandlers)
+                        {
+                            handler.HandleGlobalUntargetedMessage(ref message, this);
+                        }
+                    }
+                    finally
+                    {
+                        _messageHandlers.Push(messageHandlers);
+                    }
+
+                    break;
                 }
             }
-            finally
+        }
+
+        private void BroadcastGlobalTargeted(ref InstanceId target, ref ITargetedMessage message)
+        {
+            switch (_globalSinks.Count)
             {
-                _messageHandlers.Push(messageHandlers);
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = _globalSinks.Keys.First();
+                    handler.HandleGlobalTargetedMessage(ref target, ref message, this);
+                    return;
+                }
+                default:
+                {
+                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
+                        _globalSinks.Keys
+                    );
+                    try
+                    {
+                        foreach (MessageHandler handler in messageHandlers)
+                        {
+                            handler.HandleGlobalTargetedMessage(ref target, ref message, this);
+                        }
+                    }
+                    finally
+                    {
+                        _messageHandlers.Push(messageHandlers);
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        private void BroadcastGlobalSourcedBroadcast(
+            ref InstanceId source,
+            ref IBroadcastMessage message
+        )
+        {
+            switch (_globalSinks.Count)
+            {
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = _globalSinks.Keys.First();
+                    handler.HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    return;
+                }
+                default:
+                {
+                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
+                        _globalSinks.Keys
+                    );
+                    try
+                    {
+                        foreach (MessageHandler handler in messageHandlers)
+                        {
+                            handler.HandleGlobalSourcedBroadcastMessage(
+                                ref source,
+                                ref message,
+                                this
+                            );
+                        }
+                    }
+                    finally
+                    {
+                        _messageHandlers.Push(messageHandlers);
+                    }
+
+                    break;
+                }
             }
         }
 
         private bool TryGetInterceptorCaches(
             Type type,
-            out SortedDictionary<int, List<object>> interceptors,
-            out List<int> interceptorKeys,
-            out List<object> interceptorStack
+            out List<List<object>> interceptorStack,
+            out List<object> interceptorObjects
         )
         {
-            if (!_interceptsByType.TryGetValue(type, out interceptors) || interceptors.Count <= 0)
+            if (
+                !_interceptsByType.TryGetValue(
+                    type,
+                    out SortedDictionary<int, List<object>> interceptors
+                )
+                || interceptors.Count <= 0
+            )
             {
-                interceptorKeys = default;
                 interceptorStack = default;
+                interceptorObjects = default;
                 return false;
             }
 
             if (!_interceptors.TryPop(out interceptorStack))
             {
-                interceptorStack = new List<object>();
+                interceptorStack = new List<List<object>>(interceptors.Values);
+            }
+            else
+            {
+                interceptorStack.Clear();
+                interceptorStack.AddRange(interceptors.Values);
             }
 
-            if (!_interceptorKeys.TryPop(out interceptorKeys))
+            if (!_innerInterceptorsStack.TryPop(out interceptorObjects))
             {
-                interceptorKeys = new List<int>();
+                interceptorObjects = new List<object>();
             }
 
             return true;
@@ -1000,9 +1372,8 @@
             if (
                 !TryGetInterceptorCaches(
                     type,
-                    out SortedDictionary<int, List<object>> interceptors,
-                    out List<int> interceptorKeys,
-                    out List<object> interceptorStack
+                    out List<List<object>> interceptorStack,
+                    out List<object> interceptorObjects
                 )
             )
             {
@@ -1011,22 +1382,12 @@
 
             try
             {
-                interceptorKeys.Clear();
-                interceptorKeys.AddRange(interceptors.Keys);
-                foreach (int priority in interceptorKeys)
+                foreach (List<object> stack in interceptorStack)
                 {
-                    if (
-                        !interceptors.TryGetValue(priority, out List<object> untypedInterceptors)
-                        || untypedInterceptors.Count <= 0
-                    )
-                    {
-                        continue;
-                    }
-
-                    interceptorStack.Clear();
-                    interceptorStack.AddRange(untypedInterceptors);
+                    interceptorObjects.Clear();
+                    interceptorObjects.AddRange(stack);
 
-                    foreach (object transformer in interceptorStack)
+                    foreach (object transformer in interceptorObjects)
                     {
                         if (transformer is not UntargetedInterceptor<T> typedTransformer)
                         {
@@ -1043,7 +1404,7 @@
             finally
             {
                 _interceptors.Push(interceptorStack);
-                _interceptorKeys.Push(interceptorKeys);
+                _innerInterceptorsStack.Push(interceptorObjects);
             }
 
             return true;
@@ -1055,9 +1416,8 @@
             if (
                 !TryGetInterceptorCaches(
                     type,
-                    out SortedDictionary<int, List<object>> interceptors,
-                    out List<int> interceptorKeys,
-                    out List<object> interceptorStack
+                    out List<List<object>> interceptorStack,
+                    out List<object> interceptorObjects
                 )
             )
             {
@@ -1066,22 +1426,12 @@
 
             try
             {
-                interceptorKeys.Clear();
-                interceptorKeys.AddRange(interceptors.Keys);
-                foreach (int priority in interceptorKeys)
+                foreach (List<object> stack in interceptorStack)
                 {
-                    if (
-                        !interceptors.TryGetValue(priority, out List<object> untypedInterceptors)
-                        || untypedInterceptors.Count <= 0
-                    )
-                    {
-                        continue;
-                    }
+                    interceptorObjects.Clear();
+                    interceptorObjects.AddRange(stack);
 
-                    interceptorStack.Clear();
-                    interceptorStack.AddRange(untypedInterceptors);
-
-                    foreach (object transformer in interceptorStack)
+                    foreach (object transformer in interceptorObjects)
                     {
                         if (transformer is not TargetedInterceptor<T> typedTransformer)
                         {
@@ -1098,7 +1448,7 @@
             finally
             {
                 _interceptors.Push(interceptorStack);
-                _interceptorKeys.Push(interceptorKeys);
+                _innerInterceptorsStack.Push(interceptorObjects);
             }
 
             return true;
@@ -1110,9 +1460,8 @@
             if (
                 !TryGetInterceptorCaches(
                     type,
-                    out SortedDictionary<int, List<object>> interceptors,
-                    out List<int> interceptorKeys,
-                    out List<object> interceptorStack
+                    out List<List<object>> interceptorStack,
+                    out List<object> interceptorObjects
                 )
             )
             {
@@ -1121,22 +1470,12 @@
 
             try
             {
-                interceptorKeys.Clear();
-                interceptorKeys.AddRange(interceptors.Keys);
-                foreach (int priority in interceptorKeys)
+                foreach (List<object> stack in interceptorStack)
                 {
-                    if (
-                        !interceptors.TryGetValue(priority, out List<object> untypedInterceptors)
-                        || untypedInterceptors.Count <= 0
-                    )
-                    {
-                        continue;
-                    }
+                    interceptorObjects.Clear();
+                    interceptorObjects.AddRange(stack);
 
-                    interceptorStack.Clear();
-                    interceptorStack.AddRange(untypedInterceptors);
-
-                    foreach (object transformer in interceptorStack)
+                    foreach (object transformer in interceptorObjects)
                     {
                         if (transformer is not BroadcastInterceptor<T> typedTransformer)
                         {
@@ -1153,7 +1492,7 @@
             finally
             {
                 _interceptors.Push(interceptorStack);
-                _interceptorKeys.Push(interceptorKeys);
+                _innerInterceptorsStack.Push(interceptorObjects);
             }
 
             return true;
@@ -1173,15 +1512,53 @@
                 return false;
             }
 
+            if (sortedHandlers.Count == 1)
+            {
+                KeyValuePair<int, Dictionary<MessageHandler, int>> entry = sortedHandlers.First();
+                RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                return true;
+            }
+
             List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
                 GetOrAddMessageHandlerStack(sortedHandlers);
             try
             {
-                foreach (KeyValuePair<int, Dictionary<MessageHandler, int>> handlers in handlerList)
+                foreach (KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList)
+                {
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                }
+            }
+            finally
+            {
+                _sortedHandlers.Push(handlerList);
+            }
+
+            return true;
+        }
+
+        private void RunUntargetedBroadcast<TMessage>(
+            ref TMessage message,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : IMessage
+        {
+            switch (handlers.Count)
+            {
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = handlers.Keys.First();
+                    handler.HandleUntargetedMessage(ref message, this, priority);
+                    return;
+                }
+                default:
                 {
-                    int priority = handlers.Key;
                     List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                        handlers.Value.Keys
+                        handlers.Keys
                     );
                     try
                     {
@@ -1194,14 +1571,10 @@
                     {
                         _messageHandlers.Push(messageHandlers);
                     }
+
+                    break;
                 }
             }
-            finally
-            {
-                _sortedHandlers.Push(handlerList);
-            }
-
-            return true;
         }
 
         private bool InternalTargetedWithoutTargetingBroadcast<TMessage>(
@@ -1222,15 +1595,54 @@
                 return false;
             }
 
+            if (sortedHandlers.Count == 1)
+            {
+                KeyValuePair<int, Dictionary<MessageHandler, int>> entry = sortedHandlers.First();
+                RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                return true;
+            }
+
             List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
                 GetOrAddMessageHandlerStack(sortedHandlers);
             try
             {
-                foreach (KeyValuePair<int, Dictionary<MessageHandler, int>> handlers in handlerList)
+                foreach (KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList)
+                {
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                }
+            }
+            finally
+            {
+                _sortedHandlers.Push(handlerList);
+            }
+
+            return true;
+        }
+
+        private void RunTargetedWithoutTargeting<TMessage>(
+            ref InstanceId target,
+            ref TMessage message,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : ITargetedMessage
+        {
+            switch (handlers.Count)
+            {
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = handlers.Keys.First();
+                    handler.HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    return;
+                }
+                default:
                 {
-                    int priority = handlers.Key;
                     List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                        handlers.Value.Keys
+                        handlers.Keys
                     );
                     try
                     {
@@ -1248,18 +1660,14 @@
                     {
                         _messageHandlers.Push(messageHandlers);
                     }
+
+                    break;
                 }
             }
-            finally
-            {
-                _sortedHandlers.Push(handlerList);
-            }
-
-            return true;
         }
 
         private bool InternalBroadcastWithoutSource<TMessage>(
-            ref InstanceId target,
+            ref InstanceId source,
             ref TMessage message,
             Type type
         )
@@ -1276,22 +1684,66 @@
                 return false;
             }
 
+            if (sortedHandlers.Count == 1)
+            {
+                KeyValuePair<int, Dictionary<MessageHandler, int>> entry = sortedHandlers.First();
+                RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                return true;
+            }
+
             List<KeyValuePair<int, Dictionary<MessageHandler, int>>> handlerList =
                 GetOrAddMessageHandlerStack(sortedHandlers);
             try
             {
-                foreach (KeyValuePair<int, Dictionary<MessageHandler, int>> handlers in handlerList)
+                foreach (KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList)
+                {
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                }
+            }
+            finally
+            {
+                _sortedHandlers.Push(handlerList);
+            }
+
+            return true;
+        }
+
+        private void RunBroadcastWithoutSource<TMessage>(
+            ref InstanceId source,
+            ref TMessage message,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : IBroadcastMessage
+        {
+            switch (handlers.Count)
+            {
+                case <= 0:
+                {
+                    return;
+                }
+                case 1:
+                {
+                    MessageHandler handler = handlers.Keys.First();
+                    handler.HandleSourcedBroadcastWithoutSource(
+                        ref source,
+                        ref message,
+                        this,
+                        priority
+                    );
+                    return;
+                }
+                default:
                 {
-                    int priority = handlers.Key;
                     List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                        handlers.Value.Keys
+                        handlers.Keys
                     );
                     try
                     {
                         foreach (MessageHandler handler in messageHandlers)
                         {
                             handler.HandleSourcedBroadcastWithoutSource(
-                                ref target,
+                                ref source,
                                 ref message,
                                 this,
                                 priority
@@ -1302,14 +1754,10 @@
                     {
                         _messageHandlers.Push(messageHandlers);
                     }
+
+                    break;
                 }
             }
-            finally
-            {
-                _sortedHandlers.Push(handlerList);
-            }
-
-            return true;
         }
 
         private Action InternalRegisterUntargeted<T>(