com.wallstop-studios.dxmessaging 2.0.0-rc15 → 2.0.0-rc17

package/Runtime/Core/MessageBus/MessageBus.cs

@@ -11,17 +11,28 @@
     /// </summary>
     public sealed class MessageBus : IMessageBus
     {
+        private sealed class HandlerCache<TKey, TValue>
+        {
+            public readonly SortedList<TKey, TValue> handlers = new();
+            public readonly List<KeyValuePair<TKey, TValue>> cache = new();
+            public long version;
+            public long lastSeenVersion = -1;
+        }
+
+        private sealed class HandlerCache
+        {
+            public readonly Dictionary<MessageHandler, int> handlers = new();
+            public readonly List<MessageHandler> cache = new();
+            public long version;
+            public long lastSeenVersion = -1;
+        }
+
         public int RegisteredTargeted
         {
             get
             {
                 int count = 0;
-                foreach (
-                    KeyValuePair<
-                        Type,
-                        Dictionary<InstanceId, SortedList<int, SortedList<MessageHandler, int>>>
-                    > entry in _targetedSinks
-                )
+                foreach (var entry in _targetedSinks)
                 {
                     count += entry.Value.Count;
                 }
@@ -51,7 +62,7 @@
                 int count = 0;
                 foreach (var entry in _sinks)
                 {
-                    count += entry.Value.Count;
+                    count += entry.Value.handlers.Count;
                 }
 
                 return count;
@@ -75,54 +86,44 @@
 
         public RegistrationLog Log => _log;
 
-        private readonly Dictionary<Type, SortedList<int, SortedList<MessageHandler, int>>> _sinks =
-            new();
+        private readonly Dictionary<Type, HandlerCache<int, HandlerCache>> _sinks = new();
         private readonly Dictionary<
             Type,
-            Dictionary<InstanceId, SortedList<int, SortedList<MessageHandler, int>>>
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
         > _targetedSinks = new();
-
         private readonly Dictionary<
             Type,
-            Dictionary<InstanceId, SortedList<int, SortedList<MessageHandler, int>>>
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
         > _broadcastSinks = new();
+        private readonly Dictionary<Type, HandlerCache<int, HandlerCache>> _postProcessingSinks =
+            new();
         private readonly Dictionary<
             Type,
-            SortedList<int, SortedList<MessageHandler, int>>
-        > _postProcessingSinks = new();
-        private readonly Dictionary<
-            Type,
-            Dictionary<InstanceId, SortedList<int, SortedList<MessageHandler, int>>>
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
         > _postProcessingTargetedSinks = new();
         private readonly Dictionary<
             Type,
-            Dictionary<InstanceId, SortedList<int, SortedList<MessageHandler, int>>>
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
         > _postProcessingBroadcastSinks = new();
         private readonly Dictionary<
             Type,
-            SortedList<int, SortedList<MessageHandler, int>>
+            HandlerCache<int, HandlerCache>
         > _postProcessingTargetedWithoutTargetingSinks = new();
         private readonly Dictionary<
             Type,
-            SortedList<int, SortedList<MessageHandler, int>>
+            HandlerCache<int, HandlerCache>
         > _postProcessingBroadcastWithoutSourceSinks = new();
-        private readonly SortedList<MessageHandler, int> _globalSinks = new();
-        private readonly Dictionary<Type, SortedList<int, List<object>>> _interceptsByType = new();
+        private readonly HandlerCache _globalSinks = new();
+        private readonly Dictionary<Type, HandlerCache<int, List<object>>> _interceptsByType =
+            new();
         private readonly Dictionary<object, Dictionary<int, int>> _uniqueInterceptorsAndPriorities =
             new();
 
         private readonly Dictionary<Type, object> _broadcastMethodsByType = new();
+        private readonly Stack<List<object>> _innerInterceptorsStack = new();
 
         private readonly RegistrationLog _log = new();
 
-        // These are used so we aren't allocating as much every time we send messages
-        private readonly Stack<List<MessageHandler>> _messageHandlers = new();
-        private readonly Stack<
-            List<KeyValuePair<int, SortedList<MessageHandler, int>>>
-        > _sortedHandlers = 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
         {
@@ -196,10 +197,11 @@
 
         public Action RegisterGlobalAcceptAll(MessageHandler messageHandler)
         {
-            int count = _globalSinks.GetValueOrDefault(messageHandler, 0);
+            _globalSinks.version++;
+            int count = _globalSinks.handlers.GetValueOrDefault(messageHandler, 0);
 
             Type type = typeof(IMessage);
-            _globalSinks[messageHandler] = count + 1;
+            _globalSinks.handlers[messageHandler] = count + 1;
             _log.Log(
                 new MessagingRegistration(
                     messageHandler.owner,
@@ -211,6 +213,7 @@
 
             return () =>
             {
+                _globalSinks.version++;
                 _log.Log(
                     new MessagingRegistration(
                         messageHandler.owner,
@@ -219,7 +222,7 @@
                         RegistrationMethod.GlobalAcceptAll
                     )
                 );
-                if (!_globalSinks.TryGetValue(messageHandler, out count))
+                if (!_globalSinks.handlers.TryGetValue(messageHandler, out count))
                 {
                     if (MessagingDebug.enabled)
                     {
@@ -235,11 +238,11 @@
 
                 if (count <= 1)
                 {
-                    _ = _globalSinks.Remove(messageHandler);
+                    _ = _globalSinks.handlers.Remove(messageHandler);
                 }
                 else
                 {
-                    _globalSinks[messageHandler] = count - 1;
+                    _globalSinks.handlers[messageHandler] = count - 1;
                 }
             };
         }
@@ -352,18 +355,24 @@
             if (
                 !_interceptsByType.TryGetValue(
                     type,
-                    out SortedList<int, List<object>> prioritizedInterceptors
+                    out HandlerCache<int, List<object>> prioritizedInterceptors
                 )
             )
             {
-                prioritizedInterceptors = new SortedList<int, List<object>>();
+                prioritizedInterceptors = new HandlerCache<int, List<object>>();
                 _interceptsByType[type] = prioritizedInterceptors;
             }
 
-            if (!prioritizedInterceptors.TryGetValue(priority, out List<object> interceptors))
+            if (
+                !prioritizedInterceptors.handlers.TryGetValue(
+                    priority,
+                    out List<object> interceptors
+                )
+            )
             {
+                prioritizedInterceptors.version++;
                 interceptors = new List<object>();
-                prioritizedInterceptors[priority] = interceptors;
+                prioritizedInterceptors.handlers[priority] = interceptors;
             }
 
             if (
@@ -420,7 +429,7 @@
                         }
                     }
 
-                    if (priorityCount.Count <= 0)
+                    if (priorityCount.Count == 0)
                     {
                         _uniqueInterceptorsAndPriorities.Remove(interceptor);
                     }
@@ -437,12 +446,15 @@
                 bool complete = false;
                 if (removed)
                 {
-                    if (
-                        _interceptsByType.TryGetValue(type, out prioritizedInterceptors)
-                        && prioritizedInterceptors.TryGetValue(priority, out interceptors)
-                    )
+                    if (_interceptsByType.TryGetValue(type, out prioritizedInterceptors))
                     {
-                        complete = interceptors.Remove(interceptor);
+                        prioritizedInterceptors.version++;
+                        if (
+                            prioritizedInterceptors.handlers.TryGetValue(priority, out interceptors)
+                        )
+                        {
+                            complete = interceptors.Remove(interceptor);
+                        }
                     }
 
                     if (!complete && MessagingDebug.enabled)
@@ -493,7 +505,7 @@
                 return;
             }
 
-            if (0 < _globalSinks.Count)
+            if (0 < _globalSinks.handlers.Count)
             {
                 IUntargetedMessage untargetedMessage = typedMessage;
                 BroadcastGlobalUntargeted(ref untargetedMessage);
@@ -504,36 +516,73 @@
             if (
                 _postProcessingSinks.TryGetValue(
                     type,
-                    out SortedList<int, SortedList<MessageHandler, int>> sortedHandlers
+                    out HandlerCache<int, HandlerCache> sortedHandlers
                 )
-                && 0 < sortedHandlers.Count
+                && 0 < sortedHandlers.handlers.Count
             )
             {
-                foundAnyHandlers = true;
-                if (sortedHandlers.Count == 1)
-                {
-                    RunUntargetedPostProcessing(
-                        ref typedMessage,
-                        sortedHandlers.Keys[0],
-                        sortedHandlers.Values[0]
-                    );
-                }
-                else
+                List<KeyValuePair<int, HandlerCache>> handlerList = GetOrAddMessageHandlerStack(
+                    sortedHandlers
+                );
+                switch (handlerList.Count)
                 {
-                    List<KeyValuePair<int, SortedList<MessageHandler, int>>> handlerList =
-                        GetOrAddMessageHandlerStack(sortedHandlers);
-                    try
+                    case 1:
                     {
-                        foreach (
-                            KeyValuePair<int, SortedList<MessageHandler, int>> entry in handlerList
-                        )
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 2:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 3:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[2];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 4:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[2];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[3];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 5:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[2];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[3];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[4];
+                        RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    default:
+                    {
+                        foreach (KeyValuePair<int, HandlerCache> entry in handlerList)
                         {
                             RunUntargetedPostProcessing(ref typedMessage, entry.Key, entry.Value);
                         }
-                    }
-                    finally
-                    {
-                        _sortedHandlers.Push(handlerList);
+                        break;
                     }
                 }
             }
@@ -551,45 +600,69 @@
         private void RunUntargetedPostProcessing<TMessage>(
             ref TMessage typedMessage,
             int priority,
-            SortedList<MessageHandler, int> handlers
+            HandlerCache cache
         )
             where TMessage : IUntargetedMessage
         {
-            switch (handlers.Count)
+            if (cache.handlers.Count == 0)
+            {
+                return;
+            }
+
+            List<MessageHandler> list = cache.cache;
+            if (cache.version != cache.lastSeenVersion)
             {
-                case <= 0:
+                list.Clear();
+                Dictionary<MessageHandler, int>.KeyCollection keys = cache.handlers.Keys;
+                foreach (MessageHandler handler in keys)
                 {
-                    return;
+                    list.Add(handler);
                 }
+                cache.lastSeenVersion = cache.version;
+            }
+
+            switch (list.Count)
+            {
                 case 1:
                 {
-                    MessageHandler handler = handlers.Keys[0];
-                    handler.HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[0].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
                     return;
                 }
-                default:
+                case 2:
                 {
-                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                        handlers.Keys
-                    );
-                    try
-                    {
-                        foreach (MessageHandler handler in messageHandlers)
-                        {
-                            handler.HandleUntargetedPostProcessing(
-                                ref typedMessage,
-                                this,
-                                priority
-                            );
-                        }
-                    }
-                    finally
-                    {
-                        _messageHandlers.Push(messageHandlers);
-                    }
-
-                    break;
+                    list[0].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[1].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    return;
+                }
+                case 3:
+                {
+                    list[0].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[1].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[2].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    return;
                 }
+                case 4:
+                {
+                    list[0].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[1].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[2].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[3].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    return;
+                }
+                case 5:
+                {
+                    list[0].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[1].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[2].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[3].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    list[4].HandleUntargetedPostProcessing(ref typedMessage, this, priority);
+                    return;
+                }
+            }
+
+            foreach (MessageHandler handler in cache.cache)
+            {
+                handler.HandleUntargetedPostProcessing(ref typedMessage, this, priority);
             }
         }
 
@@ -630,7 +703,7 @@
                 return;
             }
 
-            if (0 < _globalSinks.Count)
+            if (0 < _globalSinks.handlers.Count)
             {
                 ITargetedMessage targetedMessage = typedMessage;
                 BroadcastGlobalTargeted(ref target, ref targetedMessage);
@@ -640,37 +713,74 @@
             if (
                 _targetedSinks.TryGetValue(
                     type,
-                    out Dictionary<
-                        InstanceId,
-                        SortedList<int, SortedList<MessageHandler, int>>
-                    > targetedHandlers
+                    out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> targetedHandlers
                 )
                 && targetedHandlers.TryGetValue(
                     target,
-                    out SortedList<int, SortedList<MessageHandler, int>> sortedHandlers
+                    out HandlerCache<int, HandlerCache> sortedHandlers
                 )
-                && 0 < sortedHandlers.Count
+                && 0 < sortedHandlers.handlers.Count
             )
             {
                 foundAnyHandlers = true;
-                if (sortedHandlers.Count == 1)
-                {
-                    RunTargetedBroadcast(
-                        ref target,
-                        ref typedMessage,
-                        sortedHandlers.Keys[0],
-                        sortedHandlers.Values[0]
-                    );
-                }
-                else
+                List<KeyValuePair<int, HandlerCache>> handlerList = GetOrAddMessageHandlerStack(
+                    sortedHandlers
+                );
+                switch (handlerList.Count)
                 {
-                    List<KeyValuePair<int, SortedList<MessageHandler, int>>> handlerList =
-                        GetOrAddMessageHandlerStack(sortedHandlers);
-                    try
+                    case 1:
                     {
-                        foreach (
-                            KeyValuePair<int, SortedList<MessageHandler, int>> entry in handlerList
-                        )
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 2:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 3:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[2];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 4:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[2];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[3];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 5:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[2];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[3];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[4];
+                        RunTargetedBroadcast(ref target, ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    default:
+                    {
+                        foreach (KeyValuePair<int, HandlerCache> entry in handlerList)
                         {
                             RunTargetedBroadcast(
                                 ref target,
@@ -679,10 +789,8 @@
                                 entry.Value
                             );
                         }
-                    }
-                    finally
-                    {
-                        _sortedHandlers.Push(handlerList);
+
+                        break;
                     }
                 }
             }
@@ -692,28 +800,143 @@
             if (
                 _postProcessingTargetedSinks.TryGetValue(type, out targetedHandlers)
                 && targetedHandlers.TryGetValue(target, out sortedHandlers)
-                && 0 < sortedHandlers.Count
+                && 0 < sortedHandlers.handlers.Count
             )
             {
                 foundAnyHandlers = true;
-                if (sortedHandlers.Count == 1)
-                {
-                    RunTargetedPostProcessing(
-                        ref target,
-                        ref typedMessage,
-                        sortedHandlers.Keys[0],
-                        sortedHandlers.Values[0]
-                    );
-                }
-                else
+                List<KeyValuePair<int, HandlerCache>> handlerList = GetOrAddMessageHandlerStack(
+                    sortedHandlers
+                );
+                switch (handlerList.Count)
                 {
-                    List<KeyValuePair<int, SortedList<MessageHandler, int>>> handlerList =
-                        GetOrAddMessageHandlerStack(sortedHandlers);
-                    try
+                    case 1:
                     {
-                        foreach (
-                            KeyValuePair<int, SortedList<MessageHandler, int>> entry in handlerList
-                        )
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 2:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 3:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[2];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 4:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[2];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[3];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 5:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[2];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[3];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[4];
+                        RunTargetedPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    default:
+                    {
+                        foreach (KeyValuePair<int, HandlerCache> entry in handlerList)
                         {
                             RunTargetedPostProcessing(
                                 ref target,
@@ -722,37 +945,150 @@
                                 entry.Value
                             );
                         }
-                    }
-                    finally
-                    {
-                        _sortedHandlers.Push(handlerList);
+
+                        break;
                     }
                 }
             }
 
             if (
                 _postProcessingTargetedWithoutTargetingSinks.TryGetValue(type, out sortedHandlers)
-                && 0 < sortedHandlers.Count
+                && 0 < sortedHandlers.handlers.Count
             )
             {
-                if (sortedHandlers.Count == 1)
-                {
-                    RunTargetedWithoutTargetingPostProcessing(
-                        ref target,
-                        ref typedMessage,
-                        sortedHandlers.Keys[0],
-                        sortedHandlers.Values[0]
-                    );
-                }
-                else
+                List<KeyValuePair<int, HandlerCache>> handlerList = GetOrAddMessageHandlerStack(
+                    sortedHandlers
+                );
+                switch (handlerList.Count)
                 {
-                    List<KeyValuePair<int, SortedList<MessageHandler, int>>> handlerList =
-                        GetOrAddMessageHandlerStack(sortedHandlers);
-                    try
+                    case 1:
                     {
-                        foreach (
-                            KeyValuePair<int, SortedList<MessageHandler, int>> entry in handlerList
-                        )
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 2:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 3:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[2];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 4:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[2];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[3];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 5:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[2];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[3];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[4];
+                        RunTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    default:
+                    {
+                        foreach (KeyValuePair<int, HandlerCache> entry in handlerList)
                         {
                             RunTargetedWithoutTargetingPostProcessing(
                                 ref target,
@@ -761,10 +1097,8 @@
                                 entry.Value
                             );
                         }
-                    }
-                    finally
-                    {
-                        _sortedHandlers.Push(handlerList);
+
+                        break;
                     }
                 }
             }
@@ -784,146 +1118,287 @@
             ref InstanceId target,
             ref TMessage typedMessage,
             int priority,
-            SortedList<MessageHandler, int> handlers
+            HandlerCache cache
         )
             where TMessage : ITargetedMessage
         {
-            switch (handlers.Count)
+            if (cache.handlers.Count == 0)
+            {
+                return;
+            }
+
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(cache);
+            switch (messageHandlers.Count)
             {
-                case <= 0:
+                case 1:
                 {
+                    messageHandlers[0]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = handlers.Keys[0];
-                    handler.HandleTargetedWithoutTargetingPostProcessing(
-                        ref target,
-                        ref typedMessage,
-                        this,
-                        priority
-                    );
+                    messageHandlers[0]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
                     return;
                 }
-                default:
+                case 3:
                 {
-                    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;
+                    messageHandlers[0]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[2]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    return;
+                }
+                case 4:
+                {
+                    messageHandlers[0]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[2]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[3]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[2]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[3]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[4]
+                        .HandleTargetedWithoutTargetingPostProcessing(
+                            ref target,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    return;
                 }
             }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleTargetedWithoutTargetingPostProcessing(
+                    ref target,
+                    ref typedMessage,
+                    this,
+                    priority
+                );
+            }
         }
 
         private void RunTargetedPostProcessing<TMessage>(
             ref InstanceId target,
             ref TMessage typedMessage,
             int priority,
-            SortedList<MessageHandler, int> handlers
+            HandlerCache cache
         )
             where TMessage : ITargetedMessage
         {
-            switch (handlers.Count)
+            if (cache.handlers.Count == 0)
+            {
+                return;
+            }
+
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(cache);
+            switch (messageHandlers.Count)
             {
-                case <= 0:
+                case 1:
                 {
+                    messageHandlers[0]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = handlers.Keys[0];
-                    handler.HandleTargetedPostProcessing(
-                        ref target,
-                        ref typedMessage,
-                        this,
-                        priority
-                    );
+                    messageHandlers[0]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    messageHandlers[1]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
                     return;
                 }
-                default:
+                case 3:
                 {
-                    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;
+                    messageHandlers[0]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    messageHandlers[1]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    messageHandlers[2]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    return;
+                }
+                case 4:
+                {
+                    messageHandlers[0]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    messageHandlers[1]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    messageHandlers[2]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    messageHandlers[3]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    messageHandlers[1]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    messageHandlers[2]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    messageHandlers[3]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    messageHandlers[4]
+                        .HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+                    return;
                 }
             }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleTargetedPostProcessing(ref target, ref typedMessage, this, priority);
+            }
         }
 
         private void RunTargetedBroadcast<TMessage>(
             ref InstanceId target,
             ref TMessage typedMessage,
             int priority,
-            SortedList<MessageHandler, int> handlers
+            HandlerCache cache
         )
             where TMessage : ITargetedMessage
         {
-            switch (handlers.Count)
+            if (cache.handlers.Count == 0)
+            {
+                return;
+            }
+
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(cache);
+            switch (messageHandlers.Count)
             {
-                case <= 0:
+                case 1:
                 {
+                    messageHandlers[0].HandleTargeted(ref target, ref typedMessage, this, priority);
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = handlers.Keys[0];
-                    handler.HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[0].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[1].HandleTargeted(ref target, ref typedMessage, this, priority);
                     return;
                 }
-                default:
+                case 3:
                 {
-                    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;
+                    messageHandlers[0].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[1].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[2].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    return;
+                }
+                case 4:
+                {
+                    messageHandlers[0].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[1].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[2].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[3].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[1].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[2].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[3].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    messageHandlers[4].HandleTargeted(ref target, ref typedMessage, this, priority);
+                    return;
                 }
             }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleTargeted(ref target, ref typedMessage, this, priority);
+            }
         }
 
         public void UntypedSourcedBroadcast(InstanceId source, IBroadcastMessage typedMessage)
@@ -966,7 +1441,7 @@
                 return;
             }
 
-            if (0 < _globalSinks.Count)
+            if (0 < _globalSinks.handlers.Count)
             {
                 IBroadcastMessage broadcastMessage = typedMessage;
                 BroadcastGlobalSourcedBroadcast(ref source, ref broadcastMessage);
@@ -976,44 +1451,79 @@
             if (
                 _broadcastSinks.TryGetValue(
                     type,
-                    out Dictionary<
-                        InstanceId,
-                        SortedList<int, SortedList<MessageHandler, int>>
-                    > broadcastHandlers
+                    out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> broadcastHandlers
                 )
                 && broadcastHandlers.TryGetValue(
                     source,
-                    out SortedList<int, SortedList<MessageHandler, int>> sortedHandlers
+                    out HandlerCache<int, HandlerCache> sortedHandlers
                 )
-                && 0 < sortedHandlers.Count
+                && 0 < sortedHandlers.handlers.Count
             )
             {
                 foundAnyHandlers = true;
-                if (sortedHandlers.Count == 1)
-                {
-                    RunBroadcast(
-                        ref source,
-                        ref typedMessage,
-                        sortedHandlers.Keys[0],
-                        sortedHandlers.Values[0]
-                    );
-                }
-                else
+                List<KeyValuePair<int, HandlerCache>> handlerList = GetOrAddMessageHandlerStack(
+                    sortedHandlers
+                );
+                switch (handlerList.Count)
                 {
-                    List<KeyValuePair<int, SortedList<MessageHandler, int>>> handlerList =
-                        GetOrAddMessageHandlerStack(sortedHandlers);
-                    try
+                    case 1:
                     {
-                        foreach (
-                            KeyValuePair<int, SortedList<MessageHandler, int>> entry in handlerList
-                        )
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 2:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 3:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[2];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 4:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[2];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[3];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    case 5:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[1];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[2];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[3];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        entry = handlerList[4];
+                        RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
+                        break;
+                    }
+                    default:
+                    {
+                        foreach (KeyValuePair<int, HandlerCache> entry in handlerList)
                         {
                             RunBroadcast(ref source, ref typedMessage, entry.Key, entry.Value);
                         }
-                    }
-                    finally
-                    {
-                        _sortedHandlers.Push(handlerList);
+
+                        break;
                     }
                 }
             }
@@ -1023,28 +1533,143 @@
             if (
                 _postProcessingBroadcastSinks.TryGetValue(type, out broadcastHandlers)
                 && broadcastHandlers.TryGetValue(source, out sortedHandlers)
-                && 0 < sortedHandlers.Count
+                && 0 < sortedHandlers.handlers.Count
             )
             {
                 foundAnyHandlers = true;
-                if (sortedHandlers.Count == 1)
-                {
-                    RunBroadcastPostProcessing(
-                        ref source,
-                        ref typedMessage,
-                        sortedHandlers.Keys[0],
-                        sortedHandlers.Values[0]
-                    );
-                }
-                else
+                List<KeyValuePair<int, HandlerCache>> handlerList = GetOrAddMessageHandlerStack(
+                    sortedHandlers
+                );
+                switch (handlerList.Count)
                 {
-                    List<KeyValuePair<int, SortedList<MessageHandler, int>>> handlerList =
-                        GetOrAddMessageHandlerStack(sortedHandlers);
-                    try
+                    case 1:
                     {
-                        foreach (
-                            KeyValuePair<int, SortedList<MessageHandler, int>> entry in handlerList
-                        )
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 2:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 3:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[2];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 4:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[2];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[3];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    case 5:
+                    {
+                        KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[1];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[2];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[3];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        entry = handlerList[4];
+                        RunBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            entry.Key,
+                            entry.Value
+                        );
+                        break;
+                    }
+                    default:
+                    {
+                        foreach (KeyValuePair<int, HandlerCache> entry in handlerList)
                         {
                             RunBroadcastPostProcessing(
                                 ref source,
@@ -1053,51 +1678,29 @@
                                 entry.Value
                             );
                         }
-                    }
-                    finally
-                    {
-                        _sortedHandlers.Push(handlerList);
+
+                        break;
                     }
                 }
             }
 
             if (
                 _postProcessingBroadcastWithoutSourceSinks.TryGetValue(type, out sortedHandlers)
-                && 0 < sortedHandlers.Count
+                && 0 < sortedHandlers.handlers.Count
             )
             {
-                if (sortedHandlers.Count == 1)
+                List<KeyValuePair<int, HandlerCache>> handlerList = GetOrAddMessageHandlerStack(
+                    sortedHandlers
+                );
+                foreach (KeyValuePair<int, HandlerCache> entry in handlerList)
                 {
                     RunBroadcastWithoutSourcePostProcessing(
                         ref source,
                         ref typedMessage,
-                        sortedHandlers.Keys[0],
-                        sortedHandlers.Values[0]
+                        entry.Key,
+                        entry.Value
                     );
                 }
-                else
-                {
-                    List<KeyValuePair<int, SortedList<MessageHandler, int>>> handlerList =
-                        GetOrAddMessageHandlerStack(sortedHandlers);
-                    try
-                    {
-                        foreach (
-                            KeyValuePair<int, SortedList<MessageHandler, int>> entry in handlerList
-                        )
-                        {
-                            RunBroadcastWithoutSourcePostProcessing(
-                                ref source,
-                                ref typedMessage,
-                                entry.Key,
-                                entry.Value
-                            );
-                        }
-                    }
-                    finally
-                    {
-                        _sortedHandlers.Push(handlerList);
-                    }
-                }
             }
 
             if (!foundAnyHandlers && MessagingDebug.enabled)
@@ -1115,51 +1718,19 @@
             ref InstanceId source,
             ref TMessage typedMessage,
             int priority,
-            SortedList<MessageHandler, int> handlers
+            HandlerCache cache
         )
             where TMessage : IBroadcastMessage
         {
-            switch (handlers.Count)
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(cache);
+            foreach (MessageHandler handler in messageHandlers)
             {
-                case <= 0:
-                {
-                    return;
-                }
-                case 1:
-                {
-                    MessageHandler handler = handlers.Keys[0];
-                    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;
-                }
+                handler.HandleSourcedBroadcastWithoutSourcePostProcessing(
+                    ref source,
+                    ref typedMessage,
+                    this,
+                    priority
+                );
             }
         }
 
@@ -1167,171 +1738,333 @@
             ref InstanceId source,
             ref TMessage typedMessage,
             int priority,
-            SortedList<MessageHandler, int> handlers
+            HandlerCache cache
         )
             where TMessage : IBroadcastMessage
         {
-            switch (handlers.Count)
+            if (cache.handlers.Count == 0)
+            {
+                return;
+            }
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(cache);
+            switch (messageHandlers.Count)
             {
-                case <= 0:
+                case 1:
                 {
+                    messageHandlers[0]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = handlers.Keys[0];
-                    handler.HandleSourcedBroadcastPostProcessing(
-                        ref source,
-                        ref typedMessage,
-                        this,
-                        priority
-                    );
+                    messageHandlers[0]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
                     return;
                 }
-                default:
+                case 3:
                 {
-                    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;
+                    messageHandlers[0]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[2]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    return;
+                }
+                case 4:
+                {
+                    messageHandlers[0]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[2]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[3]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[2]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[3]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    messageHandlers[4]
+                        .HandleSourcedBroadcastPostProcessing(
+                            ref source,
+                            ref typedMessage,
+                            this,
+                            priority
+                        );
+                    return;
                 }
             }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleSourcedBroadcastPostProcessing(
+                    ref source,
+                    ref typedMessage,
+                    this,
+                    priority
+                );
+            }
         }
 
         private void RunBroadcast<TMessage>(
             ref InstanceId source,
             ref TMessage typedMessage,
             int priority,
-            SortedList<MessageHandler, int> handlers
+            HandlerCache cache
         )
             where TMessage : IBroadcastMessage
         {
-            switch (handlers.Count)
+            if (cache.handlers.Count == 0)
             {
-                case <= 0:
+                return;
+            }
+
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(cache);
+            switch (messageHandlers.Count)
+            {
+                case 1:
                 {
+                    messageHandlers[0]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = handlers.Keys[0];
-                    handler.HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[0]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[1]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
                     return;
                 }
-                default:
+                case 3:
                 {
-                    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;
+                    messageHandlers[0]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[1]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[2]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    return;
+                }
+                case 4:
+                {
+                    messageHandlers[0]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[1]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[2]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[3]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[1]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[2]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[3]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    messageHandlers[4]
+                        .HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+                    return;
                 }
             }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleSourcedBroadcast(ref source, ref typedMessage, this, priority);
+            }
         }
 
         private void BroadcastGlobalUntargeted(ref IUntargetedMessage message)
         {
-            switch (_globalSinks.Count)
+            if (_globalSinks.handlers.Count == 0)
+            {
+                return;
+            }
+
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(_globalSinks);
+            switch (messageHandlers.Count)
             {
-                case <= 0:
+                case 1:
                 {
+                    messageHandlers[0].HandleGlobalUntargetedMessage(ref message, this);
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = _globalSinks.Keys[0];
-                    handler.HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[0].HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[1].HandleGlobalUntargetedMessage(ref message, this);
                     return;
                 }
-                default:
+                case 3:
                 {
-                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                        _globalSinks.Keys
-                    );
-                    try
-                    {
-                        foreach (MessageHandler handler in messageHandlers)
-                        {
-                            handler.HandleGlobalUntargetedMessage(ref message, this);
-                        }
-                    }
-                    finally
-                    {
-                        _messageHandlers.Push(messageHandlers);
-                    }
-
-                    break;
+                    messageHandlers[0].HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[1].HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[2].HandleGlobalUntargetedMessage(ref message, this);
+                    return;
+                }
+                case 4:
+                {
+                    messageHandlers[0].HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[1].HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[2].HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[3].HandleGlobalUntargetedMessage(ref message, this);
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0].HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[1].HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[2].HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[3].HandleGlobalUntargetedMessage(ref message, this);
+                    messageHandlers[4].HandleGlobalUntargetedMessage(ref message, this);
+                    return;
                 }
             }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleGlobalUntargetedMessage(ref message, this);
+            }
         }
 
         private void BroadcastGlobalTargeted(ref InstanceId target, ref ITargetedMessage message)
         {
-            switch (_globalSinks.Count)
+            if (_globalSinks.handlers.Count == 0)
             {
-                case <= 0:
+                return;
+            }
+
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(_globalSinks);
+            switch (messageHandlers.Count)
+            {
+                case 1:
                 {
+                    messageHandlers[0].HandleGlobalTargetedMessage(ref target, ref message, this);
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = _globalSinks.Keys[0];
-                    handler.HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[0].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[1].HandleGlobalTargetedMessage(ref target, ref message, this);
                     return;
                 }
-                default:
+                case 3:
                 {
-                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                        _globalSinks.Keys
-                    );
-                    try
-                    {
-                        foreach (MessageHandler handler in messageHandlers)
-                        {
-                            handler.HandleGlobalTargetedMessage(ref target, ref message, this);
-                        }
-                    }
-                    finally
-                    {
-                        _messageHandlers.Push(messageHandlers);
-                    }
-
-                    break;
+                    messageHandlers[0].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[1].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[2].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    return;
+                }
+                case 4:
+                {
+                    messageHandlers[0].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[1].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[2].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[3].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[1].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[2].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[3].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    messageHandlers[4].HandleGlobalTargetedMessage(ref target, ref message, this);
+                    return;
                 }
             }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleGlobalTargetedMessage(ref target, ref message, this);
+            }
         }
 
         private void BroadcastGlobalSourcedBroadcast(
@@ -1339,100 +2072,103 @@
             ref IBroadcastMessage message
         )
         {
-            switch (_globalSinks.Count)
+            if (_globalSinks.handlers.Count == 0)
+            {
+                return;
+            }
+
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(_globalSinks);
+            switch (messageHandlers.Count)
             {
-                case <= 0:
+                case 1:
                 {
+                    messageHandlers[0]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = _globalSinks.Keys[0];
-                    handler.HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[0]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[1]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
                     return;
                 }
-                default:
+                case 3:
                 {
-                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                        _globalSinks.Keys
-                    );
-                    try
-                    {
-                        foreach (MessageHandler handler in messageHandlers)
-                        {
-                            handler.HandleGlobalSourcedBroadcastMessage(
-                                ref source,
-                                ref message,
-                                this
-                            );
-                        }
-                    }
-                    finally
-                    {
-                        _messageHandlers.Push(messageHandlers);
-                    }
-
-                    break;
+                    messageHandlers[0]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[1]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[2]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    return;
+                }
+                case 4:
+                {
+                    messageHandlers[0]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[1]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[2]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[3]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[1]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[2]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[3]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    messageHandlers[4]
+                        .HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+                    return;
                 }
             }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleGlobalSourcedBroadcastMessage(ref source, ref message, this);
+            }
         }
 
         private bool TryGetInterceptorCaches(
             Type type,
-            out List<List<object>> interceptorStack,
+            out List<KeyValuePair<int, List<object>>> interceptorStack,
             out List<object> interceptorObjects
         )
         {
             if (
-                !_interceptsByType.TryGetValue(type, out SortedList<int, List<object>> interceptors)
-                || interceptors.Count <= 0
-            )
-            {
-                interceptorStack = default;
-                interceptorObjects = default;
-                return false;
-            }
-
-            if (!_interceptors.TryPop(out interceptorStack))
-            {
-                interceptorStack = new List<List<object>>(interceptors.Values);
-            }
-            else
-            {
-                interceptorStack.Clear();
-                switch (interceptors.Values)
-                {
-                    case List<List<object>> list:
-                    {
-                        foreach (List<object> interceptor in list)
-                        {
-                            interceptorStack.Add(interceptor);
-                        }
-
-                        break;
-                    }
-                    case List<object>[] array:
-                    {
-                        foreach (List<object> interceptor in array)
-                        {
-                            interceptorStack.Add(interceptor);
-                        }
-
-                        break;
-                    }
-                    default:
-                    {
-                        // ReSharper disable once ForCanBeConvertedToForeach
-                        // ReSharper disable once LoopCanBeConvertedToQuery
-                        for (int i = 0; i < interceptors.Values.Count; i++)
-                        {
-                            List<object> interceptor = interceptors.Values[i];
-                            interceptorStack.Add(interceptor);
-                        }
+                !_interceptsByType.TryGetValue(
+                    type,
+                    out HandlerCache<int, List<object>> interceptors
+                )
+                || interceptors.handlers.Count == 0
+            )
+            {
+                interceptorStack = default;
+                interceptorObjects = default;
+                return false;
+            }
 
-                        break;
-                    }
+            interceptorStack = interceptors.cache;
+            if (interceptors.version != interceptors.lastSeenVersion)
+            {
+                interceptorStack.Clear();
+                IList<int> keys = interceptors.handlers.Keys;
+                IList<List<object>> values = interceptors.handlers.Values;
+                for (int i = 0; i < interceptors.handlers.Count; ++i)
+                {
+                    interceptorStack.Add(new KeyValuePair<int, List<object>>(keys[i], values[i]));
                 }
+
+                interceptors.lastSeenVersion = interceptors.version;
             }
 
             if (!_innerInterceptorsStack.TryPop(out interceptorObjects))
@@ -1449,7 +2185,7 @@
             if (
                 !TryGetInterceptorCaches(
                     type,
-                    out List<List<object>> interceptorStack,
+                    out List<KeyValuePair<int, List<object>>> interceptorStack,
                     out List<object> interceptorObjects
                 )
             )
@@ -1459,10 +2195,10 @@
 
             try
             {
-                foreach (List<object> stack in interceptorStack)
+                foreach (KeyValuePair<int, List<object>> entry in interceptorStack)
                 {
                     interceptorObjects.Clear();
-                    foreach (object interceptor in stack)
+                    foreach (object interceptor in entry.Value)
                     {
                         interceptorObjects.Add(interceptor);
                     }
@@ -1483,7 +2219,6 @@
             }
             finally
             {
-                _interceptors.Push(interceptorStack);
                 _innerInterceptorsStack.Push(interceptorObjects);
             }
 
@@ -1496,7 +2231,7 @@
             if (
                 !TryGetInterceptorCaches(
                     type,
-                    out List<List<object>> interceptorStack,
+                    out List<KeyValuePair<int, List<object>>> interceptorStack,
                     out List<object> interceptorObjects
                 )
             )
@@ -1506,10 +2241,10 @@
 
             try
             {
-                foreach (List<object> stack in interceptorStack)
+                foreach (KeyValuePair<int, List<object>> entry in interceptorStack)
                 {
                     interceptorObjects.Clear();
-                    foreach (object interceptor in stack)
+                    foreach (object interceptor in entry.Value)
                     {
                         interceptorObjects.Add(interceptor);
                     }
@@ -1530,7 +2265,6 @@
             }
             finally
             {
-                _interceptors.Push(interceptorStack);
                 _innerInterceptorsStack.Push(interceptorObjects);
             }
 
@@ -1543,7 +2277,7 @@
             if (
                 !TryGetInterceptorCaches(
                     type,
-                    out List<List<object>> interceptorStack,
+                    out List<KeyValuePair<int, List<object>>> interceptorStack,
                     out List<object> interceptorObjects
                 )
             )
@@ -1553,10 +2287,10 @@
 
             try
             {
-                foreach (List<object> stack in interceptorStack)
+                foreach (KeyValuePair<int, List<object>> entry in interceptorStack)
                 {
                     interceptorObjects.Clear();
-                    foreach (object interceptor in stack)
+                    foreach (object interceptor in entry.Value)
                     {
                         interceptorObjects.Add(interceptor);
                     }
@@ -1577,7 +2311,6 @@
             }
             finally
             {
-                _interceptors.Push(interceptorStack);
                 _innerInterceptorsStack.Push(interceptorObjects);
             }
 
@@ -1588,82 +2321,133 @@
             where TMessage : IMessage
         {
             if (
-                !_sinks.TryGetValue(
-                    type,
-                    out SortedList<int, SortedList<MessageHandler, int>> sortedHandlers
-                )
-                || sortedHandlers.Count <= 0
+                !_sinks.TryGetValue(type, out HandlerCache<int, HandlerCache> sortedHandlers)
+                || sortedHandlers.handlers.Count == 0
             )
             {
                 return false;
             }
 
-            if (sortedHandlers.Count == 1)
-            {
-                RunUntargetedBroadcast(
-                    ref message,
-                    sortedHandlers.Keys[0],
-                    sortedHandlers.Values[0]
-                );
-                return true;
-            }
+            List<KeyValuePair<int, HandlerCache>> handlerList = GetOrAddMessageHandlerStack(
+                sortedHandlers
+            );
 
-            List<KeyValuePair<int, SortedList<MessageHandler, int>>> handlerList =
-                GetOrAddMessageHandlerStack(sortedHandlers);
-            try
+            switch (handlerList.Count)
             {
-                foreach (KeyValuePair<int, SortedList<MessageHandler, int>> entry in handlerList)
+                case 1:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 2:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 3:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    entry = handlerList[2];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 4:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    entry = handlerList[2];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    entry = handlerList[3];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 5:
                 {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    entry = handlerList[2];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    entry = handlerList[3];
                     RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    entry = handlerList[4];
+                    RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
+                    return true;
                 }
             }
-            finally
+
+            foreach (KeyValuePair<int, HandlerCache> entry in handlerList)
             {
-                _sortedHandlers.Push(handlerList);
+                RunUntargetedBroadcast(ref message, entry.Key, entry.Value);
             }
-
             return true;
         }
 
         private void RunUntargetedBroadcast<TMessage>(
             ref TMessage message,
             int priority,
-            SortedList<MessageHandler, int> handlers
+            HandlerCache cache
         )
             where TMessage : IMessage
         {
-            switch (handlers.Count)
+            if (cache.handlers.Count == 0)
             {
-                case <= 0:
+                return;
+            }
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(cache);
+            switch (messageHandlers.Count)
+            {
+                case 1:
                 {
+                    messageHandlers[0].HandleUntargetedMessage(ref message, this, priority);
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = handlers.Keys[0];
-                    handler.HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[0].HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[1].HandleUntargetedMessage(ref message, this, priority);
                     return;
                 }
-                default:
+                case 3:
                 {
-                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                        handlers.Keys
-                    );
-                    try
-                    {
-                        foreach (MessageHandler handler in messageHandlers)
-                        {
-                            handler.HandleUntargetedMessage(ref message, this, priority);
-                        }
-                    }
-                    finally
-                    {
-                        _messageHandlers.Push(messageHandlers);
-                    }
-
-                    break;
+                    messageHandlers[0].HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[1].HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[2].HandleUntargetedMessage(ref message, this, priority);
+                    return;
+                }
+                case 4:
+                {
+                    messageHandlers[0].HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[1].HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[2].HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[3].HandleUntargetedMessage(ref message, this, priority);
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0].HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[1].HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[2].HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[3].HandleUntargetedMessage(ref message, this, priority);
+                    messageHandlers[4].HandleUntargetedMessage(ref message, this, priority);
+                    return;
                 }
             }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleUntargetedMessage(ref message, this, priority);
+            }
         }
 
         private bool InternalTargetedWithoutTargetingBroadcast<TMessage>(
@@ -1674,39 +2458,74 @@
             where TMessage : ITargetedMessage
         {
             if (
-                !_sinks.TryGetValue(
-                    type,
-                    out SortedList<int, SortedList<MessageHandler, int>> sortedHandlers
-                )
-                || sortedHandlers.Count <= 0
+                !_sinks.TryGetValue(type, out HandlerCache<int, HandlerCache> sortedHandlers)
+                || sortedHandlers.handlers.Count == 0
             )
             {
                 return false;
             }
 
-            if (sortedHandlers.Count == 1)
-            {
-                RunTargetedWithoutTargeting(
-                    ref target,
-                    ref message,
-                    sortedHandlers.Keys[0],
-                    sortedHandlers.Values[0]
-                );
-                return true;
-            }
+            List<KeyValuePair<int, HandlerCache>> handlerList = GetOrAddMessageHandlerStack(
+                sortedHandlers
+            );
 
-            List<KeyValuePair<int, SortedList<MessageHandler, int>>> handlerList =
-                GetOrAddMessageHandlerStack(sortedHandlers);
-            try
+            switch (handlerList.Count)
             {
-                foreach (KeyValuePair<int, SortedList<MessageHandler, int>> entry in handlerList)
+                case 1:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 2:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 3:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    entry = handlerList[2];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 4:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    entry = handlerList[2];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    entry = handlerList[3];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 5:
                 {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    entry = handlerList[2];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    entry = handlerList[3];
+                    RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    entry = handlerList[4];
                     RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
+                    return true;
                 }
             }
-            finally
+
+            foreach (KeyValuePair<int, HandlerCache> entry in handlerList)
             {
-                _sortedHandlers.Push(handlerList);
+                RunTargetedWithoutTargeting(ref target, ref message, entry.Key, entry.Value);
             }
 
             return true;
@@ -1716,47 +2535,74 @@
             ref InstanceId target,
             ref TMessage message,
             int priority,
-            SortedList<MessageHandler, int> handlers
+            HandlerCache cache
         )
             where TMessage : ITargetedMessage
         {
-            switch (handlers.Count)
+            if (cache.handlers.Count == 0)
+            {
+                return;
+            }
+
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(cache);
+            switch (messageHandlers.Count)
             {
-                case <= 0:
+                case 1:
                 {
+                    messageHandlers[0]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = handlers.Keys[0];
-                    handler.HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[0]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[1]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
                     return;
                 }
-                default:
+                case 3:
                 {
-                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                        handlers.Keys
-                    );
-                    try
-                    {
-                        foreach (MessageHandler handler in messageHandlers)
-                        {
-                            handler.HandleTargetedWithoutTargeting(
-                                ref target,
-                                ref message,
-                                this,
-                                priority
-                            );
-                        }
-                    }
-                    finally
-                    {
-                        _messageHandlers.Push(messageHandlers);
-                    }
-
-                    break;
+                    messageHandlers[0]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[1]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[2]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    return;
+                }
+                case 4:
+                {
+                    messageHandlers[0]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[1]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[2]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[3]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[1]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[2]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[3]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    messageHandlers[4]
+                        .HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+                    return;
                 }
             }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleTargetedWithoutTargeting(ref target, ref message, this, priority);
+            }
         }
 
         private bool InternalBroadcastWithoutSource<TMessage>(
@@ -1767,39 +2613,73 @@
             where TMessage : IBroadcastMessage
         {
             if (
-                !_sinks.TryGetValue(
-                    type,
-                    out SortedList<int, SortedList<MessageHandler, int>> sortedHandlers
-                )
-                || sortedHandlers.Count <= 0
+                !_sinks.TryGetValue(type, out HandlerCache<int, HandlerCache> sortedHandlers)
+                || sortedHandlers.handlers.Count == 0
             )
             {
                 return false;
             }
 
-            if (sortedHandlers.Count == 1)
-            {
-                RunBroadcastWithoutSource(
-                    ref source,
-                    ref message,
-                    sortedHandlers.Keys[0],
-                    sortedHandlers.Values[0]
-                );
-                return true;
-            }
-
-            List<KeyValuePair<int, SortedList<MessageHandler, int>>> handlerList =
-                GetOrAddMessageHandlerStack(sortedHandlers);
-            try
+            List<KeyValuePair<int, HandlerCache>> handlerList = GetOrAddMessageHandlerStack(
+                sortedHandlers
+            );
+            switch (handlerList.Count)
             {
-                foreach (KeyValuePair<int, SortedList<MessageHandler, int>> entry in handlerList)
+                case 1:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 2:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 3:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    entry = handlerList[2];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 4:
+                {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    entry = handlerList[2];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    entry = handlerList[3];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    return true;
+                }
+                case 5:
                 {
+                    KeyValuePair<int, HandlerCache> entry = handlerList[0];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    entry = handlerList[1];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    entry = handlerList[2];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    entry = handlerList[3];
                     RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    entry = handlerList[4];
+                    RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
+                    return true;
                 }
             }
-            finally
+
+            foreach (KeyValuePair<int, HandlerCache> entry in handlerList)
             {
-                _sortedHandlers.Push(handlerList);
+                RunBroadcastWithoutSource(ref source, ref message, entry.Key, entry.Value);
             }
 
             return true;
@@ -1809,57 +2689,159 @@
             ref InstanceId source,
             ref TMessage message,
             int priority,
-            SortedList<MessageHandler, int> handlers
+            HandlerCache cache
         )
             where TMessage : IBroadcastMessage
         {
-            switch (handlers.Count)
+            if (cache.handlers.Count == 0)
+            {
+                return;
+            }
+
+            List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(cache);
+            switch (messageHandlers.Count)
             {
-                case <= 0:
+                case 1:
                 {
+                    messageHandlers[0]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
                     return;
                 }
-                case 1:
+                case 2:
                 {
-                    MessageHandler handler = handlers.Keys[0];
-                    handler.HandleSourcedBroadcastWithoutSource(
-                        ref source,
-                        ref message,
-                        this,
-                        priority
-                    );
+                    messageHandlers[0]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
                     return;
                 }
-                default:
+                case 3:
                 {
-                    List<MessageHandler> messageHandlers = GetOrAddMessageHandlerStack(
-                        handlers.Keys
-                    );
-                    try
-                    {
-                        foreach (MessageHandler handler in messageHandlers)
-                        {
-                            handler.HandleSourcedBroadcastWithoutSource(
-                                ref source,
-                                ref message,
-                                this,
-                                priority
-                            );
-                        }
-                    }
-                    finally
-                    {
-                        _messageHandlers.Push(messageHandlers);
-                    }
-
-                    break;
+                    messageHandlers[0]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    messageHandlers[2]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    return;
                 }
+                case 4:
+                {
+                    messageHandlers[0]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    messageHandlers[2]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    messageHandlers[3]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    return;
+                }
+                case 5:
+                {
+                    messageHandlers[0]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    messageHandlers[1]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    messageHandlers[2]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    messageHandlers[3]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    messageHandlers[4]
+                        .HandleSourcedBroadcastWithoutSource(
+                            ref source,
+                            ref message,
+                            this,
+                            priority
+                        );
+                    return;
+                }
+            }
+
+            foreach (MessageHandler handler in messageHandlers)
+            {
+                handler.HandleSourcedBroadcastWithoutSource(
+                    ref source,
+                    ref message,
+                    this,
+                    priority
+                );
             }
         }
 
         private Action InternalRegisterUntargeted<T>(
             MessageHandler messageHandler,
-            Dictionary<Type, SortedList<int, SortedList<MessageHandler, int>>> sinks,
+            Dictionary<Type, HandlerCache<int, HandlerCache>> sinks,
             RegistrationMethod registrationMethod,
             int priority
         )
@@ -1873,23 +2855,21 @@
             InstanceId handlerOwnerId = messageHandler.owner;
             Type type = typeof(T);
 
-            if (
-                !sinks.TryGetValue(
-                    type,
-                    out SortedList<int, SortedList<MessageHandler, int>> handlers
-                )
-            )
+            if (!sinks.TryGetValue(type, out HandlerCache<int, HandlerCache> handlers))
             {
-                handlers = new SortedList<int, SortedList<MessageHandler, int>>();
+                handlers = new HandlerCache<int, HandlerCache>();
                 sinks[type] = handlers;
             }
 
-            if (!handlers.TryGetValue(priority, out SortedList<MessageHandler, int> handler))
+            if (!handlers.handlers.TryGetValue(priority, out HandlerCache cache))
             {
-                handler = new SortedList<MessageHandler, int>();
-                handlers[priority] = handler;
+                handlers.version++;
+                cache = new HandlerCache();
+                handlers.handlers[priority] = cache;
             }
 
+            Dictionary<MessageHandler, int> handler = cache.handlers;
+            cache.version++;
             int count = handler.GetValueOrDefault(messageHandler, 0);
 
             handler[messageHandler] = count + 1;
@@ -1904,6 +2884,7 @@
 
             return () =>
             {
+                cache.version++;
                 _log.Log(
                     new MessagingRegistration(
                         handlerOwnerId,
@@ -1914,8 +2895,8 @@
                 );
                 if (
                     !sinks.TryGetValue(type, out handlers)
-                    || !handlers.TryGetValue(priority, out handler)
-                    || !handler.TryGetValue(messageHandler, out count)
+                    || !handlers.handlers.TryGetValue(priority, out cache)
+                    || !cache.handlers.TryGetValue(messageHandler, out count)
                 )
                 {
                     if (MessagingDebug.enabled)
@@ -1931,16 +2912,18 @@
                     return;
                 }
 
+                handlers.version++;
+                handler = cache.handlers;
                 if (count <= 1)
                 {
                     bool complete = handler.Remove(messageHandler);
 
-                    if (handler.Count <= 0)
+                    if (handler.Count == 0)
                     {
-                        _ = handlers.Remove(priority);
+                        _ = handlers.handlers.Remove(priority);
                     }
 
-                    if (handlers.Count <= 0)
+                    if (handlers.handlers.Count == 0)
                     {
                         _ = sinks.Remove(type);
                     }
@@ -1965,10 +2948,7 @@
         private Action InternalRegisterWithContext<T>(
             InstanceId context,
             MessageHandler messageHandler,
-            Dictionary<
-                Type,
-                Dictionary<InstanceId, SortedList<int, SortedList<MessageHandler, int>>>
-            > sinks,
+            Dictionary<Type, Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> sinks,
             RegistrationMethod registrationMethod,
             int priority
         )
@@ -1982,35 +2962,34 @@
             if (
                 !sinks.TryGetValue(
                     type,
-                    out Dictionary<
-                        InstanceId,
-                        SortedList<int, SortedList<MessageHandler, int>>
-                    > broadcastHandlers
+                    out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> broadcastHandlers
                 )
             )
             {
-                broadcastHandlers =
-                    new Dictionary<InstanceId, SortedList<int, SortedList<MessageHandler, int>>>();
+                broadcastHandlers = new Dictionary<InstanceId, HandlerCache<int, HandlerCache>>();
                 sinks[type] = broadcastHandlers;
             }
 
             if (
                 !broadcastHandlers.TryGetValue(
                     context,
-                    out SortedList<int, SortedList<MessageHandler, int>> handlers
+                    out HandlerCache<int, HandlerCache> handlers
                 )
             )
             {
-                handlers = new SortedList<int, SortedList<MessageHandler, int>>();
+                handlers = new HandlerCache<int, HandlerCache>();
                 broadcastHandlers[context] = handlers;
             }
 
-            if (!handlers.TryGetValue(priority, out SortedList<MessageHandler, int> handler))
+            if (!handlers.handlers.TryGetValue(priority, out HandlerCache cache))
             {
-                handler = new SortedList<MessageHandler, int>();
-                handlers[priority] = handler;
+                handlers.version++;
+                cache = new HandlerCache();
+                handlers.handlers[priority] = cache;
             }
 
+            cache.version++;
+            Dictionary<MessageHandler, int> handler = cache.handlers;
             int count = handler.GetValueOrDefault(messageHandler, 0);
 
             handler[messageHandler] = count + 1;
@@ -2025,6 +3004,7 @@
 
             return () =>
             {
+                cache.version++;
                 _log.Log(
                     new MessagingRegistration(
                         context,
@@ -2036,8 +3016,8 @@
                 if (
                     !sinks.TryGetValue(type, out broadcastHandlers)
                     || !broadcastHandlers.TryGetValue(context, out handlers)
-                    || !handlers.TryGetValue(priority, out handler)
-                    || !handler.TryGetValue(messageHandler, out count)
+                    || !handlers.handlers.TryGetValue(priority, out cache)
+                    || !cache.handlers.TryGetValue(messageHandler, out count)
                 )
                 {
                     if (MessagingDebug.enabled)
@@ -2053,20 +3033,22 @@
                     return;
                 }
 
+                handler = cache.handlers;
                 if (count <= 1)
                 {
                     bool complete = handler.Remove(messageHandler);
-                    if (handler.Count <= 0)
+                    if (handler.Count == 0)
                     {
-                        _ = handlers.Remove(priority);
+                        handlers.version++;
+                        _ = handlers.handlers.Remove(priority);
                     }
 
-                    if (handlers.Count <= 0)
+                    if (handlers.handlers.Count == 0)
                     {
                         _ = broadcastHandlers.Remove(context);
                     }
 
-                    if (broadcastHandlers.Count <= 0)
+                    if (broadcastHandlers.Count == 0)
                     {
                         _ = sinks.Remove(type);
                     }
@@ -2088,104 +3070,45 @@
             };
         }
 
-        private List<
-            KeyValuePair<int, SortedList<MessageHandler, int>>
-        > GetOrAddMessageHandlerStack(
-            IEnumerable<KeyValuePair<int, SortedList<MessageHandler, int>>> handlers
+        private static List<KeyValuePair<int, HandlerCache>> GetOrAddMessageHandlerStack(
+            HandlerCache<int, HandlerCache> cache
         )
         {
-            if (
-                !_sortedHandlers.TryPop(
-                    out List<KeyValuePair<int, SortedList<MessageHandler, int>>> messageHandlers
-                )
-            )
+            if (cache.version == cache.lastSeenVersion)
             {
-                return new List<KeyValuePair<int, SortedList<MessageHandler, int>>>(handlers);
+                return cache.cache;
             }
 
-            messageHandlers.Clear();
-            if (handlers is SortedList<int, SortedList<MessageHandler, int>> sortedList)
-            {
-                for (int i = 0; i < sortedList.Count; ++i)
-                {
-                    messageHandlers.Add(
-                        new KeyValuePair<int, SortedList<MessageHandler, int>>(
-                            sortedList.Keys[i],
-                            sortedList.Values[i]
-                        )
-                    );
-                }
-            }
-            else
+            List<KeyValuePair<int, HandlerCache>> list = cache.cache;
+            list.Clear();
+            SortedList<int, HandlerCache> handlers = cache.handlers;
+            IList<int> keys = handlers.Keys;
+            IList<HandlerCache> values = handlers.Values;
+            for (int i = 0; i < handlers.Count; i++)
             {
-                foreach (KeyValuePair<int, SortedList<MessageHandler, int>> handler in handlers)
-                {
-                    messageHandlers.Add(handler);
-                }
+                list.Add(new KeyValuePair<int, HandlerCache>(keys[i], values[i]));
             }
-            return messageHandlers;
+
+            cache.lastSeenVersion = cache.version;
+            return list;
         }
 
-        private List<MessageHandler> GetOrAddMessageHandlerStack(
-            IEnumerable<MessageHandler> handlers
-        )
+        private static List<MessageHandler> GetOrAddMessageHandlerStack(HandlerCache cache)
         {
-            if (!_messageHandlers.TryPop(out List<MessageHandler> messageHandlers))
+            if (cache.version == cache.lastSeenVersion)
             {
-                return new List<MessageHandler>(handlers);
+                return cache.cache;
             }
 
-            messageHandlers.Clear();
-            // Try to avoid allocations if at all possible
-            switch (handlers)
+            List<MessageHandler> list = cache.cache;
+            list.Clear();
+            Dictionary<MessageHandler, int>.KeyCollection keys = cache.handlers.Keys;
+            foreach (MessageHandler key in keys)
             {
-                case List<MessageHandler> list:
-                {
-                    foreach (MessageHandler handler in list)
-                    {
-                        messageHandlers.Add(handler);
-                    }
-
-                    break;
-                }
-                case MessageHandler[] array:
-                {
-                    foreach (MessageHandler handler in array)
-                    {
-                        messageHandlers.Add(handler);
-                    }
-
-                    break;
-                }
-                case IList<MessageHandler> interfaceList:
-                {
-                    for (int i = 0; i < interfaceList.Count; ++i)
-                    {
-                        messageHandlers.Add(interfaceList[i]);
-                    }
-
-                    break;
-                }
-                case HashSet<MessageHandler> set:
-                {
-                    foreach (MessageHandler handler in set)
-                    {
-                        messageHandlers.Add(handler);
-                    }
-
-                    break;
-                }
-                default:
-                {
-                    foreach (MessageHandler handler in handlers)
-                    {
-                        messageHandlers.Add(handler);
-                    }
-                    break;
-                }
+                list.Add(key);
             }
-
-            return messageHandlers;
+            cache.lastSeenVersion = cache.version;
+            return list;
         }
 
         // https://blogs.msmvps.com/jonskeet/2008/08/09/making-reflection-fly-and-exploring-delegates/