com.wallstop-studios.dxmessaging 2.0.0-rc08 → 2.0.0-rc10

package/Runtime/Core/MessageBus/MessageBus.cs

@@ -33,42 +33,39 @@
 
         public RegistrationLog Log => _log;
 
+        private readonly Dictionary<Type, SortedList<int, Dictionary<MessageHandler, int>>> _sinks =
+            new();
         private readonly Dictionary<
             Type,
-            SortedDictionary<int, Dictionary<MessageHandler, int>>
-        > _sinks = new();
-        private readonly Dictionary<
-            Type,
-            Dictionary<InstanceId, SortedDictionary<int, Dictionary<MessageHandler, int>>>
+            Dictionary<InstanceId, SortedList<int, Dictionary<MessageHandler, int>>>
         > _targetedSinks = new();
 
         private readonly Dictionary<
             Type,
-            Dictionary<InstanceId, SortedDictionary<int, Dictionary<MessageHandler, int>>>
+            Dictionary<InstanceId, SortedList<int, Dictionary<MessageHandler, int>>>
         > _broadcastSinks = new();
         private readonly Dictionary<
             Type,
-            SortedDictionary<int, Dictionary<MessageHandler, int>>
+            SortedList<int, Dictionary<MessageHandler, int>>
         > _postProcessingSinks = new();
         private readonly Dictionary<
             Type,
-            Dictionary<InstanceId, SortedDictionary<int, Dictionary<MessageHandler, int>>>
+            Dictionary<InstanceId, SortedList<int, Dictionary<MessageHandler, int>>>
         > _postProcessingTargetedSinks = new();
         private readonly Dictionary<
             Type,
-            Dictionary<InstanceId, SortedDictionary<int, Dictionary<MessageHandler, int>>>
+            Dictionary<InstanceId, SortedList<int, Dictionary<MessageHandler, int>>>
         > _postProcessingBroadcastSinks = new();
         private readonly Dictionary<
             Type,
-            SortedDictionary<int, Dictionary<MessageHandler, int>>
+            SortedList<int, Dictionary<MessageHandler, int>>
         > _postProcessingTargetedWithoutTargetingSinks = new();
         private readonly Dictionary<
             Type,
-            SortedDictionary<int, Dictionary<MessageHandler, int>>
+            SortedList<int, Dictionary<MessageHandler, int>>
         > _postProcessingBroadcastWithoutSourceSinks = new();
         private readonly Dictionary<MessageHandler, int> _globalSinks = new();
-        private readonly Dictionary<Type, SortedDictionary<int, List<object>>> _interceptsByType =
-            new();
+        private readonly Dictionary<Type, SortedList<int, List<object>>> _interceptsByType = new();
         private readonly Dictionary<object, Dictionary<int, int>> _uniqueInterceptorsAndPriorities =
             new();
 
@@ -309,11 +306,11 @@
             if (
                 !_interceptsByType.TryGetValue(
                     type,
-                    out SortedDictionary<int, List<object>> prioritizedInterceptors
+                    out SortedList<int, List<object>> prioritizedInterceptors
                 )
             )
             {
-                prioritizedInterceptors = new SortedDictionary<int, List<object>>();
+                prioritizedInterceptors = new SortedList<int, List<object>>();
                 _interceptsByType[type] = prioritizedInterceptors;
             }
 
@@ -394,12 +391,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)
@@ -461,44 +458,35 @@
             if (
                 _postProcessingSinks.TryGetValue(
                     type,
-                    out SortedDictionary<int, Dictionary<MessageHandler, int>> sortedHandlers
+                    out SortedList<int, Dictionary<MessageHandler, int>> sortedHandlers
                 )
                 && 0 < sortedHandlers.Count
             )
             {
                 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 +500,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;
@@ -561,50 +594,45 @@
                     type,
                     out Dictionary<
                         InstanceId,
-                        SortedDictionary<int, Dictionary<MessageHandler, int>>
+                        SortedList<int, Dictionary<MessageHandler, int>>
                     > targetedHandlers
                 )
                 && targetedHandlers.TryGetValue(
                     target,
-                    out SortedDictionary<int, Dictionary<MessageHandler, int>> sortedHandlers
+                    out SortedList<int, Dictionary<MessageHandler, int>> sortedHandlers
                 )
                 && 0 < sortedHandlers.Count
             )
             {
                 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 +645,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 (
+                            KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
+                        )
                         {
-                            foreach (MessageHandler handler in messageHandlers)
-                            {
-                                handler.HandleTargetedPostProcessing(
-                                    ref target,
-                                    ref typedMessage,
-                                    this,
-                                    priority
-                                );
-                            }
-                        }
-                        finally
-                        {
-                            _messageHandlers.Push(messageHandlers);
+                            RunTargetedPostProcessing(
+                                ref target,
+                                ref typedMessage,
+                                entry.Key,
+                                entry.Value
+                            );
                         }
                     }
-                }
-                finally
-                {
-                    _sortedHandlers.Push(handlerList);
+                    finally
+                    {
+                        _sortedHandlers.Push(handlerList);
+                    }
                 }
             }
 
@@ -658,39 +681,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 (
+                            KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
+                        )
                         {
-                            foreach (MessageHandler handler in messageHandlers)
-                            {
-                                handler.HandleTargetedWithoutTargetingPostProcessing(
-                                    ref target,
-                                    ref typedMessage,
-                                    this,
-                                    priority
-                                );
-                            }
-                        }
-                        finally
-                        {
-                            _messageHandlers.Push(messageHandlers);
+                            RunTargetedWithoutTargetingPostProcessing(
+                                ref target,
+                                ref typedMessage,
+                                entry.Key,
+                                entry.Value
+                            );
                         }
                     }
-                }
-                finally
-                {
-                    _sortedHandlers.Push(handlerList);
+                    finally
+                    {
+                        _sortedHandlers.Push(handlerList);
+                    }
                 }
             }
 
@@ -705,6 +728,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;
@@ -757,50 +926,40 @@
                     type,
                     out Dictionary<
                         InstanceId,
-                        SortedDictionary<int, Dictionary<MessageHandler, int>>
+                        SortedList<int, Dictionary<MessageHandler, int>>
                     > broadcastHandlers
                 )
                 && broadcastHandlers.TryGetValue(
                     source,
-                    out SortedDictionary<int, Dictionary<MessageHandler, int>> sortedHandlers
+                    out SortedList<int, Dictionary<MessageHandler, int>> sortedHandlers
                 )
                 && 0 < sortedHandlers.Count
             )
             {
                 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 (
+                            KeyValuePair<int, Dictionary<MessageHandler, int>> entry in handlerList
+                        )
                         {
-                            foreach (MessageHandler handler in messageHandlers)
-                            {
-                                handler.HandleSourcedBroadcast(
-                                    ref source,
-                                    ref typedMessage,
-                                    this,
-                                    priority
-                                );
-                            }
-                        }
-                        finally
-                        {
-                            _messageHandlers.Push(messageHandlers);
+                            RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
                         }
                     }
-                }
-                finally
-                {
-                    _sortedHandlers.Push(handlerList);
+                    finally
+                    {
+                        _sortedHandlers.Push(handlerList);
+                    }
                 }
             }
 
@@ -813,39 +972,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 +1013,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,45 +1060,226 @@
             }
         }
 
-        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)
+                case 1:
+                {
+                    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;
+                }
+            }
+        }
+
+        private void RunBroadcastPostProcessing<TMessage>(
+            ref InstanceId source,
+            ref TMessage typedMessage,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : IBroadcastMessage
+        {
+            switch (handlers.Count)
             {
-                return;
+                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;
+                }
             }
+        }
 
-            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(_globalSinks.Keys);
-            try
+        private void RunBroadcast<TMessage>(
+            ref InstanceId source,
+            ref TMessage typedMessage,
+            int priority,
+            Dictionary<MessageHandler, int> handlers
+        )
+            where TMessage : IBroadcastMessage
+        {
+            switch (handlers.Count)
             {
-                foreach (MessageHandler handler in messageHandlers)
+                case <= 0:
                 {
-                    handler.HandleGlobalTargetedMessage(ref target, ref message, this);
+                    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;
                 }
             }
-            finally
+        }
+
+        private void BroadcastGlobalUntargeted(ref IUntargetedMessage message)
+        {
+            switch (_globalSinks.Count)
             {
-                _messageHandlers.Push(messageHandlers);
+                case <= 0:
+                {
+                    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;
+                }
+            }
+        }
+
+        private void BroadcastGlobalTargeted(ref InstanceId target, ref ITargetedMessage message)
+        {
+            switch (_globalSinks.Count)
+            {
+                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;
+                }
             }
         }
 
@@ -948,22 +1288,41 @@
             ref IBroadcastMessage message
         )
         {
-            if (_globalSinks.Count <= 0)
+            switch (_globalSinks.Count)
             {
-                return;
-            }
-
-            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(_globalSinks.Keys);
-            try
-            {
-                foreach (MessageHandler handler in messageHandlers)
+                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;
                 }
-            }
-            finally
-            {
-                _messageHandlers.Push(messageHandlers);
             }
         }
 
@@ -974,10 +1333,7 @@
         )
         {
             if (
-                !_interceptsByType.TryGetValue(
-                    type,
-                    out SortedDictionary<int, List<object>> interceptors
-                )
+                !_interceptsByType.TryGetValue(type, out SortedList<int, List<object>> interceptors)
                 || interceptors.Count <= 0
             )
             {
@@ -1142,7 +1498,7 @@
             if (
                 !_sinks.TryGetValue(
                     type,
-                    out SortedDictionary<int, Dictionary<MessageHandler, int>> sortedHandlers
+                    out SortedList<int, Dictionary<MessageHandler, int>> sortedHandlers
                 )
                 || sortedHandlers.Count <= 0
             )
@@ -1150,15 +1506,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
                     {
@@ -1171,14 +1565,10 @@
                     {
                         _messageHandlers.Push(messageHandlers);
                     }
+
+                    break;
                 }
             }
-            finally
-            {
-                _sortedHandlers.Push(handlerList);
-            }
-
-            return true;
         }
 
         private bool InternalTargetedWithoutTargetingBroadcast<TMessage>(
@@ -1191,7 +1581,7 @@
             if (
                 !_sinks.TryGetValue(
                     type,
-                    out SortedDictionary<int, Dictionary<MessageHandler, int>> sortedHandlers
+                    out SortedList<int, Dictionary<MessageHandler, int>> sortedHandlers
                 )
                 || sortedHandlers.Count <= 0
             )
@@ -1199,15 +1589,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
                     {
@@ -1225,18 +1654,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
         )
@@ -1245,7 +1670,7 @@
             if (
                 !_sinks.TryGetValue(
                     type,
-                    out SortedDictionary<int, Dictionary<MessageHandler, int>> sortedHandlers
+                    out SortedList<int, Dictionary<MessageHandler, int>> sortedHandlers
                 )
                 || sortedHandlers.Count <= 0
             )
@@ -1253,22 +1678,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
@@ -1279,19 +1748,15 @@
                     {
                         _messageHandlers.Push(messageHandlers);
                     }
+
+                    break;
                 }
             }
-            finally
-            {
-                _sortedHandlers.Push(handlerList);
-            }
-
-            return true;
         }
 
         private Action InternalRegisterUntargeted<T>(
             MessageHandler messageHandler,
-            Dictionary<Type, SortedDictionary<int, Dictionary<MessageHandler, int>>> sinks,
+            Dictionary<Type, SortedList<int, Dictionary<MessageHandler, int>>> sinks,
             RegistrationMethod registrationMethod,
             int priority
         )
@@ -1308,11 +1773,11 @@
             if (
                 !sinks.TryGetValue(
                     type,
-                    out SortedDictionary<int, Dictionary<MessageHandler, int>> handlers
+                    out SortedList<int, Dictionary<MessageHandler, int>> handlers
                 )
             )
             {
-                handlers = new SortedDictionary<int, Dictionary<MessageHandler, int>>();
+                handlers = new SortedList<int, Dictionary<MessageHandler, int>>();
                 sinks[type] = handlers;
             }
 
@@ -1395,7 +1860,7 @@
             MessageHandler messageHandler,
             Dictionary<
                 Type,
-                Dictionary<InstanceId, SortedDictionary<int, Dictionary<MessageHandler, int>>>
+                Dictionary<InstanceId, SortedList<int, Dictionary<MessageHandler, int>>>
             > sinks,
             RegistrationMethod registrationMethod,
             int priority
@@ -1412,27 +1877,24 @@
                     type,
                     out Dictionary<
                         InstanceId,
-                        SortedDictionary<int, Dictionary<MessageHandler, int>>
+                        SortedList<int, Dictionary<MessageHandler, int>>
                     > broadcastHandlers
                 )
             )
             {
                 broadcastHandlers =
-                    new Dictionary<
-                        InstanceId,
-                        SortedDictionary<int, Dictionary<MessageHandler, int>>
-                    >();
+                    new Dictionary<InstanceId, SortedList<int, Dictionary<MessageHandler, int>>>();
                 sinks[type] = broadcastHandlers;
             }
 
             if (
                 !broadcastHandlers.TryGetValue(
                     context,
-                    out SortedDictionary<int, Dictionary<MessageHandler, int>> handlers
+                    out SortedList<int, Dictionary<MessageHandler, int>> handlers
                 )
             )
             {
-                handlers = new SortedDictionary<int, Dictionary<MessageHandler, int>>();
+                handlers = new SortedList<int, Dictionary<MessageHandler, int>>();
                 broadcastHandlers[context] = handlers;
             }