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

package/Runtime/Core/MessageBus/MessageBus.cs

@@ -81,8 +81,8 @@
         private readonly Stack<
             List<KeyValuePair<int, Dictionary<MessageHandler, int>>>
         > _sortedHandlers = new();
-        private readonly Stack<List<object>> _interceptors = new();
-        private readonly Stack<List<int>> _interceptorKeys = new();
+        private readonly Stack<List<List<object>>> _interceptors = new();
+        private readonly Stack<List<object>> _innerInterceptorsStack = new();
 
         public Action RegisterUntargeted<T>(MessageHandler messageHandler, int priority = 0)
             where T : IUntargetedMessage
@@ -969,26 +969,36 @@
 
         private bool TryGetInterceptorCaches(
             Type type,
-            out SortedDictionary<int, List<object>> interceptors,
-            out List<int> interceptorKeys,
-            out List<object> interceptorStack
+            out List<List<object>> interceptorStack,
+            out List<object> interceptorObjects
         )
         {
-            if (!_interceptsByType.TryGetValue(type, out interceptors) || interceptors.Count <= 0)
+            if (
+                !_interceptsByType.TryGetValue(
+                    type,
+                    out SortedDictionary<int, List<object>> interceptors
+                )
+                || interceptors.Count <= 0
+            )
             {
-                interceptorKeys = default;
                 interceptorStack = default;
+                interceptorObjects = default;
                 return false;
             }
 
             if (!_interceptors.TryPop(out interceptorStack))
             {
-                interceptorStack = new List<object>();
+                interceptorStack = new List<List<object>>(interceptors.Values);
+            }
+            else
+            {
+                interceptorStack.Clear();
+                interceptorStack.AddRange(interceptors.Values);
             }
 
-            if (!_interceptorKeys.TryPop(out interceptorKeys))
+            if (!_innerInterceptorsStack.TryPop(out interceptorObjects))
             {
-                interceptorKeys = new List<int>();
+                interceptorObjects = new List<object>();
             }
 
             return true;
@@ -1000,9 +1010,8 @@
             if (
                 !TryGetInterceptorCaches(
                     type,
-                    out SortedDictionary<int, List<object>> interceptors,
-                    out List<int> interceptorKeys,
-                    out List<object> interceptorStack
+                    out List<List<object>> interceptorStack,
+                    out List<object> interceptorObjects
                 )
             )
             {
@@ -1011,22 +1020,12 @@
 
             try
             {
-                interceptorKeys.Clear();
-                interceptorKeys.AddRange(interceptors.Keys);
-                foreach (int priority in interceptorKeys)
+                foreach (List<object> stack in interceptorStack)
                 {
-                    if (
-                        !interceptors.TryGetValue(priority, out List<object> untypedInterceptors)
-                        || untypedInterceptors.Count <= 0
-                    )
-                    {
-                        continue;
-                    }
+                    interceptorObjects.Clear();
+                    interceptorObjects.AddRange(stack);
 
-                    interceptorStack.Clear();
-                    interceptorStack.AddRange(untypedInterceptors);
-
-                    foreach (object transformer in interceptorStack)
+                    foreach (object transformer in interceptorObjects)
                     {
                         if (transformer is not UntargetedInterceptor<T> typedTransformer)
                         {
@@ -1043,7 +1042,7 @@
             finally
             {
                 _interceptors.Push(interceptorStack);
-                _interceptorKeys.Push(interceptorKeys);
+                _innerInterceptorsStack.Push(interceptorObjects);
             }
 
             return true;
@@ -1055,9 +1054,8 @@
             if (
                 !TryGetInterceptorCaches(
                     type,
-                    out SortedDictionary<int, List<object>> interceptors,
-                    out List<int> interceptorKeys,
-                    out List<object> interceptorStack
+                    out List<List<object>> interceptorStack,
+                    out List<object> interceptorObjects
                 )
             )
             {
@@ -1066,22 +1064,12 @@
 
             try
             {
-                interceptorKeys.Clear();
-                interceptorKeys.AddRange(interceptors.Keys);
-                foreach (int priority in interceptorKeys)
+                foreach (List<object> stack in interceptorStack)
                 {
-                    if (
-                        !interceptors.TryGetValue(priority, out List<object> untypedInterceptors)
-                        || untypedInterceptors.Count <= 0
-                    )
-                    {
-                        continue;
-                    }
-
-                    interceptorStack.Clear();
-                    interceptorStack.AddRange(untypedInterceptors);
+                    interceptorObjects.Clear();
+                    interceptorObjects.AddRange(stack);
 
-                    foreach (object transformer in interceptorStack)
+                    foreach (object transformer in interceptorObjects)
                     {
                         if (transformer is not TargetedInterceptor<T> typedTransformer)
                         {
@@ -1098,7 +1086,7 @@
             finally
             {
                 _interceptors.Push(interceptorStack);
-                _interceptorKeys.Push(interceptorKeys);
+                _innerInterceptorsStack.Push(interceptorObjects);
             }
 
             return true;
@@ -1110,9 +1098,8 @@
             if (
                 !TryGetInterceptorCaches(
                     type,
-                    out SortedDictionary<int, List<object>> interceptors,
-                    out List<int> interceptorKeys,
-                    out List<object> interceptorStack
+                    out List<List<object>> interceptorStack,
+                    out List<object> interceptorObjects
                 )
             )
             {
@@ -1121,22 +1108,12 @@
 
             try
             {
-                interceptorKeys.Clear();
-                interceptorKeys.AddRange(interceptors.Keys);
-                foreach (int priority in interceptorKeys)
+                foreach (List<object> stack in interceptorStack)
                 {
-                    if (
-                        !interceptors.TryGetValue(priority, out List<object> untypedInterceptors)
-                        || untypedInterceptors.Count <= 0
-                    )
-                    {
-                        continue;
-                    }
-
-                    interceptorStack.Clear();
-                    interceptorStack.AddRange(untypedInterceptors);
+                    interceptorObjects.Clear();
+                    interceptorObjects.AddRange(stack);
 
-                    foreach (object transformer in interceptorStack)
+                    foreach (object transformer in interceptorObjects)
                     {
                         if (transformer is not BroadcastInterceptor<T> typedTransformer)
                         {
@@ -1153,7 +1130,7 @@
             finally
             {
                 _interceptors.Push(interceptorStack);
-                _interceptorKeys.Push(interceptorKeys);
+                _innerInterceptorsStack.Push(interceptorObjects);
             }
 
             return true;

package/Runtime/Core/MessageHandler.cs

@@ -1333,45 +1333,42 @@
 
             private Dictionary<
                 InstanceId,
-                SortedDictionary<int, Dictionary<Action<T>, int>>
+                Dictionary<int, Dictionary<Action<T>, int>>
             > _targetedHandlers;
-            private SortedDictionary<int, Dictionary<Action<T>, int>> _untargetedHandlers;
+            private Dictionary<int, Dictionary<Action<T>, int>> _untargetedHandlers;
             private Dictionary<
                 InstanceId,
-                SortedDictionary<int, Dictionary<Action<T>, int>>
+                Dictionary<int, Dictionary<Action<T>, int>>
             > _broadcastHandlers;
             private Dictionary<
                 InstanceId,
-                SortedDictionary<int, Dictionary<Action<T>, int>>
+                Dictionary<int, Dictionary<Action<T>, int>>
             > _targetedPostProcessingHandlers;
-            private SortedDictionary<
-                int,
-                Dictionary<Action<T>, int>
-            > _untargetedPostProcessingHandlers;
+            private Dictionary<int, Dictionary<Action<T>, int>> _untargetedPostProcessingHandlers;
             private Dictionary<
                 InstanceId,
-                SortedDictionary<int, Dictionary<Action<T>, int>>
+                Dictionary<int, Dictionary<Action<T>, int>>
             > _broadcastPostProcessingHandlers;
             private Dictionary<
                 InstanceId,
-                SortedDictionary<int, Dictionary<FastHandler<T>, int>>
+                Dictionary<int, Dictionary<FastHandler<T>, int>>
             > _targetedFastHandlers;
-            private SortedDictionary<int, Dictionary<FastHandler<T>, int>> _untargetedFastHandlers;
+            private Dictionary<int, Dictionary<FastHandler<T>, int>> _untargetedFastHandlers;
             private Dictionary<
                 InstanceId,
-                SortedDictionary<int, Dictionary<FastHandler<T>, int>>
+                Dictionary<int, Dictionary<FastHandler<T>, int>>
             > _broadcastFastHandlers;
             private Dictionary<
                 InstanceId,
-                SortedDictionary<int, Dictionary<FastHandler<T>, int>>
+                Dictionary<int, Dictionary<FastHandler<T>, int>>
             > _targetedPostProcessingFastHandlers;
-            private SortedDictionary<
+            private Dictionary<
                 int,
                 Dictionary<FastHandler<T>, int>
             > _untargetedPostProcessingFastHandlers;
             private Dictionary<
                 InstanceId,
-                SortedDictionary<int, Dictionary<FastHandler<T>, int>>
+                Dictionary<int, Dictionary<FastHandler<T>, int>>
             > _broadcastPostProcessingFastHandlers;
             private Dictionary<Action<IUntargetedMessage>, int> _globalUntargetedHandlers;
             private Dictionary<Action<InstanceId, ITargetedMessage>, int> _globalTargetedHandlers;
@@ -1385,35 +1382,35 @@
                 FastHandlerWithContext<IBroadcastMessage>,
                 int
             > _globalBroadcastFastHandlers;
-            private SortedDictionary<
+            private Dictionary<
                 int,
                 Dictionary<Action<InstanceId, T>, int>
             > _targetedWithoutTargetingHandlers;
-            private SortedDictionary<
+            private Dictionary<
                 int,
                 Dictionary<FastHandlerWithContext<T>, int>
             > _fastTargetedWithoutTargetingHandlers;
-            private SortedDictionary<
+            private Dictionary<
                 int,
                 Dictionary<Action<InstanceId, T>, int>
             > _broadcastWithoutSourceHandlers;
-            private SortedDictionary<
+            private Dictionary<
                 int,
                 Dictionary<FastHandlerWithContext<T>, int>
             > _fastBroadcastWithoutSourceHandlers;
-            private SortedDictionary<
+            private Dictionary<
                 int,
                 Dictionary<Action<InstanceId, T>, int>
             > _targetedWithoutTargetingPostProcessingHandlers;
-            private SortedDictionary<
+            private Dictionary<
                 int,
                 Dictionary<FastHandlerWithContext<T>, int>
             > _fastTargetedWithoutTargetingPostProcessingHandlers;
-            private SortedDictionary<
+            private Dictionary<
                 int,
                 Dictionary<Action<InstanceId, T>, int>
             > _broadcastWithoutSourcePostProcessingHandlers;
-            private SortedDictionary<
+            private Dictionary<
                 int,
                 Dictionary<FastHandlerWithContext<T>, int>
             > _fastBroadcastWithoutSourcePostProcessingHandlers;
@@ -2249,10 +2246,7 @@
 
             private static void RunFastHandlersWithContext<TMessage>(
                 ref InstanceId context,
-                SortedDictionary<
-                    int,
-                    Dictionary<FastHandlerWithContext<T>, int>
-                > fastHandlersByContext,
+                Dictionary<int, Dictionary<FastHandlerWithContext<T>, int>> fastHandlersByContext,
                 ref TMessage message,
                 int priority
             )
@@ -2276,7 +2270,7 @@
                 ref InstanceId context,
                 Dictionary<
                     InstanceId,
-                    SortedDictionary<int, Dictionary<FastHandler<T>, int>>
+                    Dictionary<int, Dictionary<FastHandler<T>, int>>
                 > fastHandlersByContext,
                 ref TMessage message,
                 int priority
@@ -2287,7 +2281,7 @@
                     fastHandlersByContext is not { Count: > 0 }
                     || !fastHandlersByContext.TryGetValue(
                         context,
-                        out SortedDictionary<int, Dictionary<FastHandler<T>, int>> fastHandlers
+                        out Dictionary<int, Dictionary<FastHandler<T>, int>> fastHandlers
                     )
                 )
                 {
@@ -2298,7 +2292,7 @@
             }
 
             private static void RunFastHandlers<TMessage>(
-                SortedDictionary<int, Dictionary<FastHandler<T>, int>> fastHandlers,
+                Dictionary<int, Dictionary<FastHandler<T>, int>> fastHandlers,
                 ref TMessage message,
                 int priority
             )
@@ -2406,7 +2400,7 @@
             private static void RunFastHandlers<TMessage, U>(
                 ref InstanceId context,
                 ref Stack<List<FastHandlerWithContext<U>>> stack,
-                SortedDictionary<int, Dictionary<FastHandlerWithContext<U>, int>> fastHandlers,
+                Dictionary<int, Dictionary<FastHandlerWithContext<U>, int>> fastHandlers,
                 ref TMessage message,
                 int priority
             )
@@ -2451,7 +2445,7 @@
                 ref InstanceId context,
                 Dictionary<
                     InstanceId,
-                    SortedDictionary<int, Dictionary<Action<T>, int>>
+                    Dictionary<int, Dictionary<Action<T>, int>>
                 > handlersByContext,
                 ref TMessage message,
                 int priority
@@ -2462,7 +2456,7 @@
                     handlersByContext is not { Count: > 0 }
                     || !handlersByContext.TryGetValue(
                         context,
-                        out SortedDictionary<int, Dictionary<Action<T>, int>> handlers
+                        out Dictionary<int, Dictionary<Action<T>, int>> handlers
                     )
                 )
                 {
@@ -2473,7 +2467,7 @@
             }
 
             private static void RunHandlers<TMessage>(
-                SortedDictionary<int, Dictionary<Action<T>, int>> sortedHandlers,
+                Dictionary<int, Dictionary<Action<T>, int>> sortedHandlers,
                 ref TMessage message,
                 int priority
             )
@@ -2510,7 +2504,7 @@
 
             private static void RunHandlers<TMessage>(
                 ref InstanceId context,
-                SortedDictionary<int, Dictionary<Action<InstanceId, T>, int>> handlers,
+                Dictionary<int, Dictionary<Action<InstanceId, T>, int>> handlers,
                 ref TMessage message,
                 int priority
             )
@@ -2568,26 +2562,23 @@
 
             private static Action AddHandler<U>(
                 InstanceId context,
-                ref Dictionary<
-                    InstanceId,
-                    SortedDictionary<int, Dictionary<U, int>>
-                > handlersByContext,
+                ref Dictionary<InstanceId, Dictionary<int, Dictionary<U, int>>> handlersByContext,
                 U handler,
                 Action deregistration,
                 int priority
             )
             {
                 handlersByContext ??=
-                    new Dictionary<InstanceId, SortedDictionary<int, Dictionary<U, int>>>();
+                    new Dictionary<InstanceId, Dictionary<int, Dictionary<U, int>>>();
 
                 if (
                     !handlersByContext.TryGetValue(
                         context,
-                        out SortedDictionary<int, Dictionary<U, int>> sortedHandlers
+                        out Dictionary<int, Dictionary<U, int>> sortedHandlers
                     )
                 )
                 {
-                    sortedHandlers = new SortedDictionary<int, Dictionary<U, int>>();
+                    sortedHandlers = new Dictionary<int, Dictionary<U, int>>();
                     handlersByContext[context] = sortedHandlers;
                 }
 
@@ -2601,10 +2592,8 @@
 
                 handlers[handler] = count + 1;
 
-                Dictionary<
-                    InstanceId,
-                    SortedDictionary<int, Dictionary<U, int>>
-                > localHandlersByContext = handlersByContext;
+                Dictionary<InstanceId, Dictionary<int, Dictionary<U, int>>> localHandlersByContext =
+                    handlersByContext;
 
                 return () =>
                 {
@@ -2675,13 +2664,13 @@
             }
 
             private static Action AddHandler<U>(
-                ref SortedDictionary<int, Dictionary<U, int>> sortedHandlers,
+                ref Dictionary<int, Dictionary<U, int>> sortedHandlers,
                 U handler,
                 Action deregistration,
                 int priority
             )
             {
-                sortedHandlers ??= new SortedDictionary<int, Dictionary<U, int>>();
+                sortedHandlers ??= new Dictionary<int, Dictionary<U, int>>();
 
                 if (
                     !sortedHandlers.TryGetValue(priority, out Dictionary<U, int> handlersByPriority)
@@ -2695,7 +2684,7 @@
 
                 handlersByPriority[handler] = count + 1;
 
-                SortedDictionary<int, Dictionary<U, int>> localSortedHandlers = sortedHandlers;
+                Dictionary<int, Dictionary<U, int>> localSortedHandlers = sortedHandlers;
                 Dictionary<U, int> localHandlers = handlersByPriority;
 
                 return () =>

package/Tests/Runtime/Benchmarks/PerformanceTests.cs

@@ -6,6 +6,7 @@
     using Core;
     using DxMessaging.Core;
     using DxMessaging.Core.Extensions;
+    using global::Unity.PerformanceTesting;
     using NUnit.Framework;
     using Scripts.Components;
     using Scripts.Messages;
@@ -20,7 +21,7 @@
         public override void Setup()
         {
             base.Setup();
-            MessagingDebug.LogFunction = (_1, _2) => { };
+            MessagingDebug.LogFunction = (_, _) => { };
         }
 
         [UnityTest]
@@ -39,23 +40,109 @@
             RunTest(component => NormalComponent(timer, timeout, component, message));
             RunTest(component => NoCopyGameObject(timer, timeout, component, message));
             RunTest(component => NoCopyComponent(timer, timeout, component, message));
-            
+
             SimpleUntargetedMessage untargetedMessage = new();
             RunTest(component => NoCopyUntargeted(timer, timeout, component, untargetedMessage));
             yield break;
         }
 
+        [UnityTest]
+        [Performance]
+        public IEnumerator BenchmarkBroadcast()
+        {
+            GameObject go = CreateGameObject();
+            MessageRegistrationToken token = GetToken(
+                go.GetComponent<EmptyMessageAwareComponent>()
+            );
+            int count = 0;
+            token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(go, Handle);
+
+            SimpleBroadcastMessage message = new();
+
+            Measure
+                .Method(() => message.EmitGameObjectBroadcast(go))
+                .WarmupCount(10)
+                .IterationsPerMeasurement(10)
+                .MeasurementCount(1_000)
+                .Run();
+            yield break;
+
+            void Handle(SimpleBroadcastMessage _)
+            {
+                ++count;
+            }
+        }
+
+        [UnityTest]
+        [Performance]
+        public IEnumerator BenchmarkTargeted()
+        {
+            GameObject go = CreateGameObject();
+            MessageRegistrationToken token = GetToken(
+                go.GetComponent<EmptyMessageAwareComponent>()
+            );
+            int count = 0;
+            token.RegisterGameObjectTargeted<SimpleTargetedMessage>(go, Handle);
+
+            SimpleTargetedMessage message = new();
+
+            Measure
+                .Method(() => message.EmitGameObjectTargeted(go))
+                .WarmupCount(10)
+                .IterationsPerMeasurement(10)
+                .MeasurementCount(1_000)
+                .Run();
+            yield break;
+
+            void Handle(SimpleTargetedMessage _)
+            {
+                ++count;
+            }
+        }
+
+        [UnityTest]
+        [Performance]
+        public IEnumerator BenchmarkUntargeted()
+        {
+            GameObject go = CreateGameObject();
+            MessageRegistrationToken token = GetToken(
+                go.GetComponent<EmptyMessageAwareComponent>()
+            );
+            int count = 0;
+            token.RegisterUntargeted<SimpleUntargetedMessage>(Handle);
+
+            SimpleUntargetedMessage message = new();
+
+            Measure
+                .Method(() => message.EmitUntargeted())
+                .WarmupCount(10)
+                .IterationsPerMeasurement(10)
+                .MeasurementCount(1_000)
+                .Run();
+            yield break;
+
+            void Handle(SimpleUntargetedMessage _)
+            {
+                ++count;
+            }
+        }
+
         private GameObject CreateGameObject()
         {
             GameObject target = new(
-                nameof(Benchmark), typeof(EmptyMessageAwareComponent), typeof(SpriteRenderer),
-                typeof(Rigidbody2D), typeof(CircleCollider2D), typeof(LineRenderer));
+                nameof(Benchmark),
+                typeof(EmptyMessageAwareComponent),
+                typeof(SpriteRenderer),
+                typeof(Rigidbody2D),
+                typeof(CircleCollider2D),
+                typeof(LineRenderer)
+            );
             _spawned.Add(target);
 
             return target;
         }
 
-        private void DisplayCount(string testName, int count, TimeSpan timeout)
+        private static void DisplayCount(string testName, int count, TimeSpan timeout)
         {
             Debug.Log($"| {testName} | {Math.Floor(count / timeout.TotalSeconds):N0} |");
         }
@@ -74,7 +161,12 @@
             }
         }
 
-        private void Unity(Stopwatch timer, TimeSpan timeout, GameObject target,  ComplexTargetedMessage message)
+        private static void Unity(
+            Stopwatch timer,
+            TimeSpan timeout,
+            GameObject target,
+            ComplexTargetedMessage message
+        )
         {
             int count = 0;
             var component = target.AddComponent<SimpleMessageAwareComponent>();
@@ -82,13 +174,20 @@
             timer.Restart();
             do
             {
-                target.SendMessage(nameof(SimpleMessageAwareComponent.HandleSlowComplexTargetedMessage), message);
-            }
-            while (timer.Elapsed < timeout);
+                target.SendMessage(
+                    nameof(SimpleMessageAwareComponent.HandleSlowComplexTargetedMessage),
+                    message
+                );
+            } while (timer.Elapsed < timeout);
             DisplayCount("Unity", count, timeout);
         }
 
-        private void NormalGameObject(Stopwatch timer, TimeSpan timeout, EmptyMessageAwareComponent component, ComplexTargetedMessage message)
+        private void NormalGameObject(
+            Stopwatch timer,
+            TimeSpan timeout,
+            EmptyMessageAwareComponent component,
+            ComplexTargetedMessage message
+        )
         {
             int count = 0;
             var token = GetToken(component);
@@ -104,12 +203,16 @@
             do
             {
                 message.EmitGameObjectTargeted(go);
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
             DisplayCount("DxMessaging (GameObject) - Normal", count, timeout);
         }
 
-        private void NormalComponent(Stopwatch timer, TimeSpan timeout, EmptyMessageAwareComponent component, ComplexTargetedMessage message)
+        private void NormalComponent(
+            Stopwatch timer,
+            TimeSpan timeout,
+            EmptyMessageAwareComponent component,
+            ComplexTargetedMessage message
+        )
         {
             int count = 0;
             var token = GetToken(component);
@@ -124,12 +227,16 @@
             do
             {
                 message.EmitComponentTargeted(component);
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
             DisplayCount("DxMessaging (Component) - Normal", count, timeout);
         }
 
-        private void NoCopyGameObject(Stopwatch timer, TimeSpan timeout, EmptyMessageAwareComponent component, ComplexTargetedMessage message)
+        private void NoCopyGameObject(
+            Stopwatch timer,
+            TimeSpan timeout,
+            EmptyMessageAwareComponent component,
+            ComplexTargetedMessage message
+        )
         {
             int count = 0;
             var token = GetToken(component);
@@ -146,12 +253,16 @@
             do
             {
                 message.EmitGameObjectTargeted(component.gameObject);
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
             DisplayCount("DxMessaging (GameObject) - No-Copy", count, timeout);
         }
 
-        private void NoCopyComponent(Stopwatch timer, TimeSpan timeout, EmptyMessageAwareComponent component, ComplexTargetedMessage message)
+        private void NoCopyComponent(
+            Stopwatch timer,
+            TimeSpan timeout,
+            EmptyMessageAwareComponent component,
+            ComplexTargetedMessage message
+        )
         {
             int count = 0;
             var token = GetToken(component);
@@ -167,12 +278,16 @@
             do
             {
                 message.EmitComponentTargeted(component);
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
             DisplayCount("DxMessaging (Component) - No-Copy", count, timeout);
         }
 
-        private void NoCopyUntargeted(Stopwatch timer, TimeSpan timeout, EmptyMessageAwareComponent component, SimpleUntargetedMessage message)
+        private void NoCopyUntargeted(
+            Stopwatch timer,
+            TimeSpan timeout,
+            EmptyMessageAwareComponent component,
+            SimpleUntargetedMessage message
+        )
         {
             int count = 0;
             var token = GetToken(component);
@@ -188,9 +303,8 @@
             do
             {
                 message.EmitUntargeted();
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
             DisplayCount("DxMessaging (Untargeted) - No-Copy", count, timeout);
         }
     }
-}
+}

package/Tests/Runtime/Core/BroadcastTests.cs

@@ -727,6 +727,10 @@
                         {
                             Assert.AreEqual(previous + 1, received[priority - 1]);
                         }
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
+                        }
                     },
                     priority: priority
                 );
@@ -740,6 +744,10 @@
                         {
                             Assert.AreEqual(previous + 1, received[priority - 1]);
                         }
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
+                        }
                     },
                     priority: priority
                 );
@@ -786,9 +794,13 @@
                     (ref SimpleBroadcastMessage _) =>
                     {
                         int previous = received[priority]++;
-                        if (0 < priority)
+                        for (int j = priority - 1; j >= 0; --j)
                         {
-                            Assert.AreEqual(previous + 1, received[priority - 1]);
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
                         }
                     },
                     priority: priority
@@ -799,9 +811,14 @@
                     {
                         int previous = received[priority]++;
                         Assert.AreEqual(1, previous % 2);
-                        if (0 < priority)
+                        for (int j = priority - 1; j >= 0; --j)
                         {
-                            Assert.AreEqual(previous + 1, received[priority - 1]);
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
                         }
                     },
                     priority: priority
@@ -828,5 +845,55 @@
             Assert.AreEqual(numRuns * 2, received.Distinct().Single());
             yield break;
         }
+
+        [UnityTest]
+        public IEnumerator Interceptor()
+        {
+            GameObject test = new(nameof(Interceptor), typeof(EmptyMessageAwareComponent));
+            _spawned.Add(test);
+
+            int[] received = new int[100];
+            EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
+            MessageRegistrationToken token = GetToken(component);
+            for (int i = 0; i < received.Length; ++i)
+            {
+                int priority = i;
+                token.RegisterBroadcastInterceptor(
+                    (ref InstanceId source, ref SimpleBroadcastMessage _) =>
+                    {
+                        int previous = received[priority]++;
+                        for (int j = priority - 1; j >= 0; --j)
+                        {
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
+                        }
+
+                        return true;
+                    },
+                    priority: priority
+                );
+            }
+
+            SimpleBroadcastMessage message = new();
+            const int numRuns = 100;
+            for (int i = 0; i < numRuns; ++i)
+            {
+                message.EmitComponentBroadcast(component);
+                message.EmitGameObjectBroadcast(test);
+            }
+
+            Assert.AreEqual(
+                1,
+                received.Distinct().Count(),
+                "Expected received to be uniform, found: [{0}].",
+                string.Join(",", received.Distinct().OrderBy(x => x))
+            );
+
+            Assert.AreEqual(numRuns * 2, received.Distinct().Single());
+            yield break;
+        }
     }
 }

package/Tests/Runtime/Core/TargetedTests.cs

@@ -713,9 +713,13 @@
                     (ref SimpleTargetedMessage _) =>
                     {
                         int previous = received[priority]++;
-                        if (0 < priority)
+                        for (int j = priority - 1; j >= 0; --j)
                         {
-                            Assert.AreEqual(previous + 1, received[priority - 1]);
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
                         }
                     },
                     priority: priority
@@ -726,9 +730,13 @@
                     {
                         int previous = received[priority]++;
                         Assert.AreEqual(1, previous % 2);
-                        if (0 < priority)
+                        for (int j = priority - 1; j >= 0; --j)
+                        {
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+                        for (int j = priority + 1; j < received.Length; ++j)
                         {
-                            Assert.AreEqual(previous + 1, received[priority - 1]);
+                            Assert.AreEqual(previous, received[j]);
                         }
                     },
                     priority: priority
@@ -776,9 +784,13 @@
                     (ref SimpleTargetedMessage _) =>
                     {
                         int previous = received[priority]++;
-                        if (0 < priority)
+                        for (int j = priority - 1; j >= 0; --j)
                         {
-                            Assert.AreEqual(previous + 1, received[priority - 1]);
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
                         }
                     },
                     priority: priority
@@ -789,9 +801,13 @@
                     {
                         int previous = received[priority]++;
                         Assert.AreEqual(1, previous % 2);
-                        if (0 < priority)
+                        for (int j = priority - 1; j >= 0; --j)
                         {
-                            Assert.AreEqual(previous + 1, received[priority - 1]);
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
                         }
                     },
                     priority: priority
@@ -818,5 +834,55 @@
             Assert.AreEqual(numRuns * 2, received.Distinct().Single());
             yield break;
         }
+
+        [UnityTest]
+        public IEnumerator Interceptor()
+        {
+            GameObject test = new(nameof(Interceptor), typeof(EmptyMessageAwareComponent));
+            _spawned.Add(test);
+
+            int[] received = new int[100];
+            EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
+            MessageRegistrationToken token = GetToken(component);
+            for (int i = 0; i < received.Length; ++i)
+            {
+                int priority = i;
+                token.RegisterTargetedInterceptor(
+                    (ref InstanceId source, ref SimpleTargetedMessage _) =>
+                    {
+                        int previous = received[priority]++;
+                        for (int j = priority - 1; j >= 0; --j)
+                        {
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
+                        }
+
+                        return true;
+                    },
+                    priority: priority
+                );
+            }
+
+            SimpleTargetedMessage message = new();
+            const int numRuns = 100;
+            for (int i = 0; i < numRuns; ++i)
+            {
+                message.EmitComponentTargeted(component);
+                message.EmitGameObjectTargeted(test);
+            }
+
+            Assert.AreEqual(
+                1,
+                received.Distinct().Count(),
+                "Expected received to be uniform, found: [{0}].",
+                string.Join(",", received.Distinct().OrderBy(x => x))
+            );
+
+            Assert.AreEqual(numRuns * 2, received.Distinct().Single());
+            yield break;
+        }
     }
 }

package/Tests/Runtime/Core/UntargetedTests.cs

@@ -172,9 +172,13 @@
                     (ref SimpleUntargetedMessage _) =>
                     {
                         int previous = received[priority]++;
-                        if (0 < priority)
+                        for (int j = priority - 1; j >= 0; --j)
                         {
-                            Assert.AreEqual(previous + 1, received[priority - 1]);
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
                         }
                     },
                     priority: priority
@@ -184,9 +188,13 @@
                     {
                         int previous = received[priority]++;
                         Assert.AreEqual(1, previous % 2);
-                        if (0 < priority)
+                        for (int j = priority - 1; j >= 0; --j)
+                        {
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+                        for (int j = priority + 1; j < received.Length; ++j)
                         {
-                            Assert.AreEqual(previous + 1, received[priority - 1]);
+                            Assert.AreEqual(previous, received[j]);
                         }
                     },
                     priority: priority
@@ -211,5 +219,54 @@
             Assert.AreEqual(numRuns * 2, received.Distinct().Single());
             yield break;
         }
+
+        [UnityTest]
+        public IEnumerator Interceptor()
+        {
+            GameObject test = new(nameof(Interceptor), typeof(EmptyMessageAwareComponent));
+            _spawned.Add(test);
+
+            int[] received = new int[100];
+            EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
+            MessageRegistrationToken token = GetToken(component);
+            for (int i = 0; i < received.Length; ++i)
+            {
+                int priority = i;
+                token.RegisterUntargetedInterceptor(
+                    (ref SimpleUntargetedMessage _) =>
+                    {
+                        int previous = received[priority]++;
+                        for (int j = priority - 1; j >= 0; --j)
+                        {
+                            Assert.AreEqual(previous + 1, received[j]);
+                        }
+                        for (int j = priority + 1; j < received.Length; ++j)
+                        {
+                            Assert.AreEqual(previous, received[j]);
+                        }
+
+                        return true;
+                    },
+                    priority: priority
+                );
+            }
+
+            SimpleUntargetedMessage message = new();
+            const int numRuns = 100;
+            for (int i = 0; i < numRuns; ++i)
+            {
+                message.EmitUntargeted();
+            }
+
+            Assert.AreEqual(
+                1,
+                received.Distinct().Count(),
+                "Expected received to be uniform, found: [{0}].",
+                string.Join(",", received.Distinct().OrderBy(x => x))
+            );
+
+            Assert.AreEqual(numRuns, received.Distinct().Single());
+            yield break;
+        }
     }
 }

package/Tests/Runtime/WallstopStudios.DxMessaging.Tests.Runtime.asmdef

@@ -4,7 +4,8 @@
     "references": [
         "UnityEngine.TestRunner",
         "UnityEditor.TestRunner",
-        "WallstopStudios.DxMessaging"
+        "WallstopStudios.DxMessaging",
+        "Unity.PerformanceTesting"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "com.wallstop-studios.dxmessaging",
-  "version": "2.0.0-rc07",
+  "version": "2.0.0-rc08",
   "displayName": "DxMessaging",
   "description": "Synchronous Event Bus for Unity",
   "unity": "2021.3",
   "dependencies": {
-    "com.wallstop-studios.unity-helpers" : "2.0.0-rc04"
+    "com.wallstop-studios.unity-helpers" : "2.0.0-rc13"
   },
   "keywords": [
     "messaging",

package/Tests/Editor.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 2f8663039d4ca4f43a9acdf5f22e30ed
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: