com.wallstop-studios.dxmessaging 2.0.0-rc27.3 → 2.0.0-rc27.3.1

package/Runtime/Core/MessageBus/MessageBus.cs

@@ -7,6 +7,7 @@ namespace DxMessaging.Core.MessageBus
     using System.Runtime.CompilerServices;
     using DataStructure;
     using Diagnostics;
+    using DxMessaging.Core;
     using Extensions;
     using Helper;
     using Messages;
@@ -177,6 +178,7 @@ namespace DxMessaging.Core.MessageBus
         );
 
         private bool _diagnosticsMode = GlobalDiagnosticsMode;
+        private bool _loggedReflexiveWarning;
 
         public Action RegisterUntargeted<T>(MessageHandler messageHandler, int priority = 0)
             where T : IUntargetedMessage
@@ -1131,6 +1133,17 @@ namespace DxMessaging.Core.MessageBus
 
             if (typeof(TMessage) == typeof(ReflexiveMessage))
             {
+                if (!_loggedReflexiveWarning)
+                {
+                    _loggedReflexiveWarning = true;
+                    if (MessagingDebug.enabled)
+                    {
+                        MessagingDebug.Log(
+                            LogLevel.Warn,
+                            "ReflexiveMessage dispatch traverses the Unity hierarchy and is significantly slower than typed messages. Prefer targeted or broadcast messages where possible."
+                        );
+                    }
+                }
 #if UNITY_2017_1_OR_NEWER
                 ref ReflexiveMessage reflexiveMessage = ref Unsafe.As<TMessage, ReflexiveMessage>(
                     ref typedMessage

package/Runtime/Core/MessageHandler.cs

@@ -1782,6 +1782,7 @@ namespace DxMessaging.Core
             public long version;
             public long lastSeenVersion = -1;
             public long lastSeenEmissionId;
+            internal int prefreezeInvocationCount;
         }
 
         /// <summary>
@@ -1895,39 +1896,16 @@ namespace DxMessaging.Core
             /// <param name="priority">Priority at which to run the handlers.</param>
             public void HandleUntargeted(ref T message, int priority, long emissionId)
             {
-                // Pre-freeze untargeted post-processors for this emission/priority
-                if (
-                    _untargetedPostProcessingFastHandlers != null
-                    && _untargetedPostProcessingFastHandlers.TryGetValue(priority, out var upf)
-                )
-                {
-                    _ = GetOrAddNewHandlerStack(upf, emissionId);
-                }
-                if (
-                    _untargetedPostProcessingHandlers != null
-                    && _untargetedPostProcessingHandlers.TryGetValue(priority, out var up)
-                )
-                {
-                    _ = GetOrAddNewHandlerStack(up, emissionId);
-                }
-                // Pre-freeze post-processors for this emission/priority
-                if (
-                    _untargetedPostProcessingFastHandlers != null
-                    && _untargetedPostProcessingFastHandlers.TryGetValue(
-                        priority,
-                        out var fastCache
-                    )
-                )
-                {
-                    _ = GetOrAddNewHandlerStack(fastCache, emissionId);
-                }
-                if (
-                    _untargetedPostProcessingHandlers != null
-                    && _untargetedPostProcessingHandlers.TryGetValue(priority, out var cache)
-                )
-                {
-                    _ = GetOrAddNewHandlerStack(cache, emissionId);
-                }
+                PrefreezeHandlersForEmission(
+                    _untargetedPostProcessingFastHandlers,
+                    priority,
+                    emissionId
+                );
+                PrefreezeHandlersForEmission(
+                    _untargetedPostProcessingHandlers,
+                    priority,
+                    emissionId
+                );
 
                 RunFastHandlers(_untargetedFastHandlers, ref message, priority, emissionId);
                 RunHandlers(_untargetedHandlers, ref message, priority, emissionId);
@@ -3535,6 +3513,22 @@ namespace DxMessaging.Core
                 return actionCache.cache;
             }
 
+            private static void PrefreezeHandlersForEmission<THandler>(
+                Dictionary<int, HandlerActionCache<THandler>> handlers,
+                int priority,
+                long emissionId
+            )
+            {
+                if (
+                    handlers != null
+                    && handlers.TryGetValue(priority, out HandlerActionCache<THandler> cache)
+                )
+                {
+                    cache.prefreezeInvocationCount++;
+                    _ = GetOrAddNewHandlerStack(cache, emissionId);
+                }
+            }
+
             private static Action AddHandler<TU>(
                 InstanceId context,
                 ref Dictionary<

package/Runtime/Core/MessageRegistrationToken.cs

@@ -59,6 +59,7 @@ namespace DxMessaging.Core
 
         private readonly Dictionary<MessageRegistrationHandle, Action> _registrations = new();
         private readonly Dictionary<MessageRegistrationHandle, Action> _deregistrations = new();
+        private readonly List<Action> _deregistrationQueue = new();
         internal readonly Dictionary<
             MessageRegistrationHandle,
             MessageRegistrationMetadata
@@ -1878,13 +1879,11 @@ namespace DxMessaging.Core
 
             if (_deregistrations is { Count: > 0 })
             {
-                Dictionary<
-                    MessageRegistrationHandle,
-                    Action
-                >.ValueCollection.Enumerator enumerator = _deregistrations.Values.GetEnumerator();
-                while (enumerator.MoveNext())
+                _deregistrationQueue.Clear();
+                _deregistrationQueue.AddRange(_deregistrations.Values);
+                foreach (Action deregistration in _deregistrationQueue)
                 {
-                    enumerator.Current();
+                    deregistration?.Invoke();
                 }
             }
 
@@ -1905,15 +1904,13 @@ namespace DxMessaging.Core
         /// </example>
         public void UnregisterAll()
         {
-            if (_enabled && _deregistrations is { Count: > 0 })
+            if (_deregistrations is { Count: > 0 })
             {
-                Dictionary<
-                    MessageRegistrationHandle,
-                    Action
-                >.ValueCollection.Enumerator enumerator = _deregistrations.Values.GetEnumerator();
-                while (enumerator.MoveNext())
+                _deregistrationQueue.Clear();
+                _deregistrationQueue.AddRange(_deregistrations.Values);
+                foreach (Action deregistration in _deregistrationQueue)
                 {
-                    enumerator.Current();
+                    deregistration?.Invoke();
                 }
             }
 
@@ -1934,16 +1931,10 @@ namespace DxMessaging.Core
         /// </example>
         public void RemoveRegistration(MessageRegistrationHandle handle)
         {
-            if (
-                _deregistrations != null
-                && _deregistrations.TryGetValue(handle, out Action deregistrationAction)
-            )
+            if (_deregistrations?.Remove(handle, out Action deregistrationAction) == true)
             {
-                deregistrationAction();
-                _ = _deregistrations.Remove(handle);
+                deregistrationAction?.Invoke();
             }
-
-            _ = _registrations?.Remove(handle);
         }
 
         /// <summary>

package/Runtime/Unity/MessageAwareComponent.cs

@@ -124,8 +124,14 @@ namespace DxMessaging.Unity
         /// </summary>
         protected virtual void OnDestroy()
         {
+            if (_messagingComponent != null)
+            {
+                _messagingComponent.Release(this);
+            }
+
             _messageRegistrationToken?.Disable();
             _messageRegistrationToken = null;
+            _messagingComponent = null;
         }
 
         /// <summary>

package/Runtime/Unity/MessagingComponent.cs

@@ -73,6 +73,30 @@ namespace DxMessaging.Unity
             return createdToken;
         }
 
+        /// <summary>
+        /// Releases the registration token previously created for <paramref name="listener"/>.
+        /// </summary>
+        /// <param name="listener">Listener whose token should be released.</param>
+        /// <remarks>
+        /// Invokes <see cref="MessageRegistrationToken.Disable"/> and removes the listener from the internal cache.
+        /// Safe to call multiple times.
+        /// </remarks>
+        public bool Release(MonoBehaviour listener)
+        {
+            if (listener is null)
+            {
+                return false;
+            }
+
+            if (_registeredListeners.Remove(listener, out MessageRegistrationToken token))
+            {
+                token?.Disable();
+                return true;
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Ensures the underlying <see cref="Core.MessageHandler"/> exists.
         /// </summary>

package/Tests/Runtime/Core/MessagingComponentLifecycleTests.cs

@@ -0,0 +1,89 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System.Collections;
+    using DxMessaging.Core;
+    using DxMessaging.Tests.Runtime.Scripts.Components;
+    using DxMessaging.Unity;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+
+    public sealed class MessagingComponentLifecycleTests : MessagingTestBase
+    {
+        [UnityTest]
+        public IEnumerator ReleasesListenerOnDestroy()
+        {
+            GameObject go = new(
+                "Lifecycle",
+                typeof(MessagingComponent),
+                typeof(SimpleMessageAwareComponent)
+            );
+            _spawned.Add(go);
+
+            MessagingComponent messaging = go.GetComponent<MessagingComponent>();
+            SimpleMessageAwareComponent listener = go.GetComponent<SimpleMessageAwareComponent>();
+
+            yield return null;
+
+            Assert.AreEqual(
+                1,
+                messaging._registeredListeners.Count,
+                "Expected initial listener registration."
+            );
+
+            Object.Destroy(listener);
+            yield return null;
+
+            Assert.AreEqual(
+                0,
+                messaging._registeredListeners.Count,
+                "Listener dictionary should be cleared after destroy."
+            );
+
+            SimpleMessageAwareComponent replacement =
+                go.AddComponent<SimpleMessageAwareComponent>();
+            yield return null;
+
+            Assert.AreEqual(
+                1,
+                messaging._registeredListeners.Count,
+                "Replacement listener should be tracked."
+            );
+            Assert.IsTrue(messaging._registeredListeners.ContainsKey(replacement));
+        }
+
+        [UnityTest]
+        public IEnumerator ManualReleaseRemovesListenerAndDisablesToken()
+        {
+            GameObject go = new(
+                "ManualRelease",
+                typeof(MessagingComponent),
+                typeof(ManualListenerComponent)
+            );
+            _spawned.Add(go);
+
+            MessagingComponent messaging = go.GetComponent<MessagingComponent>();
+            ManualListenerComponent listener = go.GetComponent<ManualListenerComponent>();
+
+            MessageRegistrationToken token = listener.RequestToken(messaging);
+            Assert.AreEqual(
+                1,
+                messaging._registeredListeners.Count,
+                "Token request should register listener."
+            );
+
+            token.Enable();
+            Assert.IsTrue(token.Enabled, "Token should enable successfully.");
+
+            messaging.Release(listener);
+            yield return null;
+
+            Assert.AreEqual(
+                0,
+                messaging._registeredListeners.Count,
+                "Manual release should remove listener."
+            );
+            Assert.IsFalse(token.Enabled, "Released token should be disabled.");
+        }
+    }
+}

package/Tests/Runtime/Core/MessagingComponentLifecycleTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 23c1f6cf389e77147b1fa5edfeb1652f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Core/ReflexiveMessageWarningTests.cs

@@ -0,0 +1,86 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using DxMessaging.Core;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Core.Messages;
+    using DxMessaging.Tests.Runtime.Scripts.Components;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+
+    public sealed class ReflexiveMessageWarningTests : MessagingTestBase
+    {
+        [UnityTest]
+        public IEnumerator LogsWarningOncePerBus()
+        {
+            List<(LogLevel level, string message)> logs = new();
+            var previousLogFunction = MessagingDebug.LogFunction;
+            try
+            {
+                MessagingDebug.LogFunction = (level, message) => logs.Add((level, message));
+                MessagingDebug.enabled = true;
+                logs.Clear();
+
+                GameObject go = new("ReflexiveReceiver", typeof(ReflexiveReceiverComponent));
+                _spawned.Add(go);
+                ReflexiveReceiverComponent receiver = go.GetComponent<ReflexiveReceiverComponent>();
+
+                MessageBus bus = new();
+                ReflexiveMessage message = new("OnReflexive", ReflexiveSendMode.Flat);
+
+                int warningsBefore = CountWarnings(logs);
+                InstanceId target = receiver;
+                bus.TargetedBroadcast(ref target, ref message);
+                Assert.AreEqual(1, receiver.InvocationCount);
+                int warningsAfter = CountWarnings(logs);
+                Assert.Greater(
+                    warningsAfter,
+                    warningsBefore,
+                    "First reflexive dispatch should log a warning."
+                );
+                StringAssert.Contains("ReflexiveMessage", logs[^1].message);
+
+                warningsBefore = warningsAfter;
+                target = receiver;
+                bus.TargetedBroadcast(ref target, ref message);
+                Assert.AreEqual(2, receiver.InvocationCount);
+                warningsAfter = CountWarnings(logs);
+                Assert.AreEqual(
+                    warningsBefore,
+                    warningsAfter,
+                    "Second dispatch on the same bus should not emit additional warnings."
+                );
+
+                MessageBus secondBus = new();
+                warningsBefore = warningsAfter;
+                target = receiver;
+                secondBus.TargetedBroadcast(ref target, ref message);
+                Assert.AreEqual(3, receiver.InvocationCount);
+                warningsAfter = CountWarnings(logs);
+                Assert.AreEqual(
+                    warningsBefore + 1,
+                    warningsAfter,
+                    "A new bus should emit its own warning."
+                );
+            }
+            finally
+            {
+                MessagingDebug.LogFunction = previousLogFunction;
+            }
+
+            yield break;
+        }
+
+        private static int CountWarnings(List<(LogLevel level, string message)> logs)
+        {
+            return logs.Count(entry =>
+                entry.level == LogLevel.Warn
+                && entry.message.IndexOf("ReflexiveMessage dispatch", StringComparison.Ordinal) >= 0
+            );
+        }
+    }
+}

package/Tests/Runtime/Core/ReflexiveMessageWarningTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9682cda4e2ef15a48869a68d1810cebe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Core/UntargetedPrefreezeTests.cs

@@ -0,0 +1,116 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using DxMessaging.Core;
+    using DxMessaging.Core.Helper;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Tests.Runtime.Scripts.Messages;
+    using NUnit.Framework;
+
+    public sealed class UntargetedPrefreezeTests
+    {
+        [Test]
+        public void PrefreezeRunsOncePerEmission()
+        {
+            MessageHandler handler = new(new InstanceId(123)) { active = true };
+            MessageBus messageBus = new();
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, messageBus);
+
+            int postProcessCount = 0;
+            _ = token.RegisterUntargeted<SimpleUntargetedMessage>(
+                (ref SimpleUntargetedMessage _) => { }
+            );
+            _ = token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(
+                (ref SimpleUntargetedMessage _) => postProcessCount++,
+                priority: 0
+            );
+
+            token.Enable();
+
+            object cache = GetUntargetedPostProcessingFastCache(
+                handler,
+                messageBus,
+                typeof(SimpleUntargetedMessage),
+                priority: 0
+            );
+
+            SimpleUntargetedMessage message = new();
+            messageBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(1, postProcessCount);
+            Assert.AreEqual(1, GetPrefreezeInvocationCount(cache));
+
+            messageBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(2, postProcessCount);
+            Assert.AreEqual(2, GetPrefreezeInvocationCount(cache));
+
+            token.Disable();
+        }
+
+        private static object GetUntargetedPostProcessingFastCache(
+            MessageHandler handler,
+            MessageBus messageBus,
+            Type messageType,
+            int priority
+        )
+        {
+            FieldInfo handlersField = typeof(MessageHandler).GetField(
+                "_handlersByTypeByMessageBus",
+                BindingFlags.NonPublic | BindingFlags.Instance
+            );
+            Assert.IsNotNull(handlersField);
+            var handlersByBus = (List<MessageCache<object>>)handlersField.GetValue(handler);
+            Assert.IsNotNull(handlersByBus);
+
+            MessageCache<object> cacheByType = handlersByBus[
+                messageBus.RegisteredGlobalSequentialIndex
+            ];
+            MethodInfo getOrAddMethod = typeof(MessageCache<object>)
+                .GetMethod(nameof(MessageCache<object>.GetOrAdd))
+                ?.MakeGenericMethod(messageType);
+            Assert.IsNotNull(getOrAddMethod);
+
+            object typedHandler = getOrAddMethod.Invoke(cacheByType, null);
+            Assert.IsNotNull(typedHandler);
+
+            FieldInfo fastHandlersField = typedHandler
+                .GetType()
+                .GetField(
+                    "_untargetedPostProcessingFastHandlers",
+                    BindingFlags.NonPublic | BindingFlags.Instance
+                );
+            Assert.IsNotNull(fastHandlersField);
+
+            object fastHandlers = fastHandlersField.GetValue(typedHandler);
+            Assert.IsNotNull(fastHandlers);
+
+            return GetDictionaryValue(fastHandlers, priority);
+        }
+
+        private static object GetDictionaryValue(object dictionary, int key)
+        {
+            MethodInfo tryGetValue = dictionary
+                .GetType()
+                .GetMethod("TryGetValue", BindingFlags.Public | BindingFlags.Instance);
+            Assert.IsNotNull(tryGetValue);
+
+            object[] args = { key, null };
+            bool found = (bool)tryGetValue.Invoke(dictionary, args);
+            Assert.IsTrue(found, $"Failed to locate cache for priority {key}.");
+            return args[1];
+        }
+
+        private static int GetPrefreezeInvocationCount(object handlerCache)
+        {
+            FieldInfo countField = handlerCache
+                .GetType()
+                .GetField(
+                    "prefreezeInvocationCount",
+                    BindingFlags.NonPublic | BindingFlags.Instance
+                );
+            Assert.IsNotNull(countField);
+            return (int)countField.GetValue(handlerCache);
+        }
+    }
+}

package/Tests/Runtime/Core/UntargetedPrefreezeTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9a36705993094444a95042994d092fc3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,14 @@
+namespace DxMessaging.Tests.Runtime.Scripts.Components
+{
+    using UnityEngine;
+
+    public sealed class ReflexiveReceiverComponent : MonoBehaviour
+    {
+        public int InvocationCount { get; private set; }
+
+        public void OnReflexive()
+        {
+            InvocationCount++;
+        }
+    }
+}

package/Tests/Runtime/Scripts/Components/ReflexiveReceiverComponent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d7c3fab9fe20b6944814c031134be8e6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/package.json

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