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

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;
+        }
     }
 }