com.wallstop-studios.dxmessaging 2.0.0-rc21 → 2.0.0-rc23

package/Tests/Runtime/Benchmarks/PerformanceTests.cs

@@ -5,6 +5,7 @@
     using Core;
     using DxMessaging.Core;
     using DxMessaging.Core.Extensions;
+    using DxMessaging.Core.Messages;
     using global::Unity.PerformanceTesting;
     using NUnit.Framework;
     using Scripts.Components;
@@ -30,9 +31,16 @@
             Debug.Log("| ------------ | ------------------- | ------------ | ");
 
             ComplexTargetedMessage message = new(Guid.NewGuid());
+            DxReflexiveMessage reflexiveMessage = new(
+                nameof(SimpleMessageAwareComponent.HandleSlowComplexTargetedMessage),
+                ReflexiveSendMode.Flat,
+                message
+            );
+
             Stopwatch timer = Stopwatch.StartNew();
 
             RunTest(component => Unity(timer, timeout, component.gameObject, message));
+
             RunTest(component => NormalGameObject(timer, timeout, component, message));
             RunTest(component => NormalComponent(timer, timeout, component, message));
             RunTest(component => NoCopyGameObject(timer, timeout, component, message));
@@ -40,6 +48,11 @@
 
             SimpleUntargetedMessage untargetedMessage = new();
             RunTest(component => NoCopyUntargeted(timer, timeout, component, untargetedMessage));
+            RunTest(component =>
+                ReflexiveOneArgument(timer, timeout, component.gameObject, reflexiveMessage)
+            );
+            RunTest(component => ReflexiveTwoArguments(timer, timeout, component.gameObject));
+            RunTest(component => ReflexiveThreeArguments(timer, timeout, component.gameObject));
         }
 
         [Test]
@@ -181,7 +194,10 @@
         )
         {
             int count = 0;
-            var component = target.AddComponent<SimpleMessageAwareComponent>();
+            if (!target.TryGetComponent(out SimpleMessageAwareComponent component))
+            {
+                component = target.AddComponent<SimpleMessageAwareComponent>();
+            }
             component.slowComplexTargetedHandler = () => ++count;
             // Pre-warm
             target.SendMessage(
@@ -221,6 +237,130 @@
             DisplayCount("Unity", count, timeout, allocating);
         }
 
+        private static void ReflexiveThreeArguments(
+            Stopwatch timer,
+            TimeSpan timeout,
+            GameObject go
+        )
+        {
+            int count = 0;
+            if (!go.TryGetComponent(out SimpleMessageAwareComponent component))
+            {
+                component = go.AddComponent<SimpleMessageAwareComponent>();
+            }
+            component.reflexiveThreeArgumentHandler = () => ++count;
+            DxReflexiveMessage message = new(
+                nameof(SimpleMessageAwareComponent.HandleReflexiveMessageThreeArguments),
+                ReflexiveSendMode.Flat,
+                1,
+                2,
+                3
+            );
+            InstanceId target = go;
+            // Pre-warm
+            message.EmitTargeted(target);
+
+            timer.Restart();
+            do
+            {
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    message.EmitTargeted(target);
+                }
+            } while (timer.Elapsed < timeout);
+            bool allocating;
+            try
+            {
+                Assert.That(() => message.EmitTargeted(target), Is.Not.AllocatingGCMemory());
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
+
+            DisplayCount("Reflexive (Three Arguments)", count, timeout, allocating);
+        }
+
+        private static void ReflexiveTwoArguments(Stopwatch timer, TimeSpan timeout, GameObject go)
+        {
+            int count = 0;
+            if (!go.TryGetComponent(out SimpleMessageAwareComponent component))
+            {
+                component = go.AddComponent<SimpleMessageAwareComponent>();
+            }
+            component.reflexiveTwoArgumentHandler = () => ++count;
+            DxReflexiveMessage message = new(
+                nameof(SimpleMessageAwareComponent.HandleReflexiveMessageTwoArguments),
+                ReflexiveSendMode.Flat,
+                1,
+                2
+            );
+            InstanceId target = go;
+            // Pre-warm
+            message.EmitTargeted(target);
+
+            timer.Restart();
+            do
+            {
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    message.EmitTargeted(target);
+                }
+            } while (timer.Elapsed < timeout);
+            bool allocating;
+            try
+            {
+                Assert.That(() => message.EmitTargeted(target), Is.Not.AllocatingGCMemory());
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
+
+            DisplayCount("Reflexive (Two Arguments)", count, timeout, allocating);
+        }
+
+        private static void ReflexiveOneArgument(
+            Stopwatch timer,
+            TimeSpan timeout,
+            GameObject go,
+            DxReflexiveMessage message
+        )
+        {
+            int count = 0;
+            if (!go.TryGetComponent(out SimpleMessageAwareComponent component))
+            {
+                component = go.AddComponent<SimpleMessageAwareComponent>();
+            }
+            component.slowComplexTargetedHandler = () => ++count;
+            InstanceId target = go;
+            // Pre-warm
+            message.EmitTargeted(target);
+
+            timer.Restart();
+            do
+            {
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    message.EmitTargeted(target);
+                }
+            } while (timer.Elapsed < timeout);
+            bool allocating;
+            try
+            {
+                Assert.That(() => message.EmitTargeted(target), Is.Not.AllocatingGCMemory());
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
+
+            DisplayCount("Reflexive (One Argument)", count, timeout, allocating);
+        }
+
         private void NormalGameObject(
             Stopwatch timer,
             TimeSpan timeout,

package/Tests/Runtime/Core/MessagingTestBase.cs

@@ -154,20 +154,12 @@
             }
         }
 
-        protected MessageRegistrationToken GetToken(MessageAwareComponent component)
+        protected static MessageRegistrationToken GetToken(MessageAwareComponent component)
         {
-            // Reach inside and grab the token
-            FieldInfo field = typeof(MessageAwareComponent).GetField(
-                "_messageRegistrationToken",
-                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
-            );
-            Assert.IsNotNull(field);
-            MessageRegistrationToken token = field.GetValue(component) as MessageRegistrationToken;
-            Assert.IsNotNull(token);
-            return token;
+            return component.Token;
         }
 
-        protected IEnumerator WaitUntilMessageHandlerIsFresh()
+        protected static IEnumerator WaitUntilMessageHandlerIsFresh()
         {
             MessageBus messageBus = MessageHandler.MessageBus;
             Assert.IsNotNull(messageBus);

package/Tests/Runtime/Scripts/Components/SimpleMessageAwareComponent.cs

@@ -37,6 +37,8 @@
         public Action componentTargetedHandler;
         public Action complexComponentTargetedHandler;
         public Action componentBroadcastHandler;
+        public Action reflexiveTwoArgumentHandler;
+        public Action reflexiveThreeArgumentHandler;
 
         private bool _slowComplexTargetingEnabled = true;
         private bool _fastComplexTargetingEnabled = true;
@@ -122,6 +124,16 @@
             }
         }
 
+        public void HandleReflexiveMessageTwoArguments(int a, int b)
+        {
+            reflexiveTwoArgumentHandler?.Invoke();
+        }
+
+        public void HandleReflexiveMessageThreeArguments(int a, int b, int c)
+        {
+            reflexiveThreeArgumentHandler?.Invoke();
+        }
+
         public void HandleSlowComplexTargetedMessage(ComplexTargetedMessage message)
         {
             slowComplexTargetedHandler?.Invoke();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.dxmessaging",
-  "version": "2.0.0-rc21",
+  "version": "2.0.0-rc23",
   "displayName": "DxMessaging",
   "description": "Synchronous Event Bus for Unity",
   "unity": "2021.3",