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

package/README.md

@@ -39,12 +39,15 @@ For UntargetedMessages, DxMessaging is significantly faster (roughly 2x) than Un
 
 | Message Tech | Operations / Second | Allocations? |
 | ------------ | ------------------- | ------------ | 
-| Unity | 2,566,400 | Yes |
-| DxMessaging (GameObject) - Normal | 2,726,400 | No |
-| DxMessaging (Component) - Normal | 2,749,000 | No |
-| DxMessaging (GameObject) - No-Copy | 2,883,800 | No |
-| DxMessaging (Component) - No-Copy | 2,855,200 | No |
-| DxMessaging (Untargeted) - No-Copy | 4,499,000 | No |
+| Unity | 2,670,600 | Yes |
+| DxMessaging (GameObject) - Normal | 2,722,400 | No |
+| DxMessaging (Component) - Normal | 2,738,800 | No |
+| DxMessaging (GameObject) - No-Copy | 2,871,800 | No |
+| DxMessaging (Component) - No-Copy | 2,876,600 | No |
+| DxMessaging (Untargeted) - No-Copy | 4,480,200 | No |
+| Reflexive (One Argument) | 2,287,800 | No |
+| Reflexive (Two Arguments) | 1,009,000 | No |
+| Reflexive (Three Arguments) | 1,000,400 | No |
 
 # Functionality
 While not as fast, DxMessaging offers *additional functionality* as compared to Unity's messaging solution.

package/Runtime/Core/Extensions/EnumExtensions.cs

@@ -0,0 +1,37 @@
+namespace DxMessaging.Core.Extensions
+{
+    using System;
+    using System.Runtime.CompilerServices;
+
+    public static class EnumExtensions
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool HasFlagNoAlloc<T>(this T value, T flag)
+            where T : unmanaged, Enum
+        {
+            ulong valueUnderlying = GetUInt64(value);
+            ulong flagUnderlying = GetUInt64(flag);
+            return (valueUnderlying & flagUnderlying) == flagUnderlying;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe ulong GetUInt64<T>(T value)
+            where T : unmanaged
+        {
+            /*
+                Works because T is constrained to unmanaged, so it's safe to reinterpret
+                All enums are value types and have a fixed size
+             */
+            return sizeof(T) switch
+            {
+                1 => *(byte*)&value,
+                2 => *(ushort*)&value,
+                4 => *(uint*)&value,
+                8 => *(ulong*)&value,
+                _ => throw new ArgumentException(
+                    $"Unsupported enum size: {sizeof(T)} for type {typeof(T)}"
+                ),
+            };
+        }
+    }
+}

package/Runtime/Core/Extensions/EnumExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f01ee914d7634a69a85f86bb02f2f07e
+timeCreated: 1745162639

package/Runtime/Core/InstanceId.cs

@@ -26,9 +26,7 @@
         public InstanceId(int id)
         {
             _id = id;
-#if UNITY_2017_1_OR_NEWER
             Object = null;
-#endif
         }
 
 #if UNITY_2017_1_OR_NEWER

package/Runtime/Core/MessageBus/IMessageBus.cs

@@ -1,6 +1,7 @@
 namespace DxMessaging.Core.MessageBus
 {
     using System;
+    using System.Threading;
     using Core;
     using Messages;
 
@@ -9,7 +10,10 @@
     /// </summary>
     public interface IMessageBus
     {
-        public static int GlobalSequentialIndex = -1;
+        internal static int GlobalSequentialIndex = -1;
+
+        protected static int GenerateNewGlobalSequentialIndex() =>
+            Interlocked.Increment(ref GlobalSequentialIndex);
 
         public int RegisteredGlobalSequentialIndex { get; }
         public int RegisteredBroadcast { get; }
@@ -19,7 +23,7 @@
         public int RegisteredUntargeted { get; }
 
         /// <summary>
-        /// Given an Untargeted message, determines whether or not it should be processed or skipped
+        /// Given an Untargeted message, determines whether it should be processed or skipped
         /// </summary>
         /// <typeparam name="TMessage">Specific type of message.</typeparam>
         /// <param name="message">Message to consider.</param>
@@ -28,7 +32,7 @@
             where TMessage : IUntargetedMessage;
 
         /// <summary>
-        /// Given a Targeted message and its target, determines whether or not it should be processed or skipped.
+        /// Given a Targeted message and its target, determines whether it should be processed or skipped.
         /// </summary>
         /// <typeparam name="TMessage">Specific type of message.</typeparam>
         /// <param name="target">Target of the message.</param>
@@ -41,7 +45,7 @@
             where TMessage : ITargetedMessage;
 
         /// <summary>
-        /// Given a Broadcast message and its source, determines whether or not it should be processed or skipped.
+        /// Given a Broadcast message and its source, determines whether it should be processed or skipped.
         /// </summary>
         /// <typeparam name="TMessage">Specific type of message.</typeparam>
         /// <param name="source">Source of the message.</param>

package/Runtime/Core/MessageBus/MessageBus.cs

@@ -2,11 +2,16 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Linq.Expressions;
     using System.Reflection;
-    using System.Threading;
+    using System.Runtime.CompilerServices;
+    using Extensions;
     using Helper;
     using Messages;
     using static IMessageBus;
+#if UNITY_2017_1_OR_NEWER
+    using UnityEngine;
+#endif
 
     /// <summary>
     /// Instanced MessageBus for use cases where you want distinct islands of MessageBuses.
@@ -43,7 +48,7 @@
             }
         }
 
-        public int RegisteredGlobalSequentialIndex { get; private set; }
+        public int RegisteredGlobalSequentialIndex { get; } = GenerateNewGlobalSequentialIndex();
 
         public int RegisteredBroadcast
         {
@@ -77,9 +82,12 @@
 
         // For use with re-broadcasting to generic methods
         private static readonly object[] ReflectionMethodArgumentsCache = new object[2];
+        private static readonly List<Expression> ArgumentExpressionsCache = new();
 
         private const BindingFlags ReflectionHelperBindingFlags =
             BindingFlags.Static | BindingFlags.NonPublic;
+        private const BindingFlags ReflexiveMethodBindingFlags =
+            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
 
         private delegate void FastUntargetedBroadcast<T>(ref T message)
             where T : IUntargetedMessage;
@@ -118,6 +126,16 @@
         private readonly Dictionary<Type, object> _broadcastMethodsByType = new();
         private readonly Stack<List<object>> _innerInterceptorsStack = new();
 
+        private readonly Dictionary<
+            Type,
+            Dictionary<MethodSignatureKey, Action<MonoBehaviour, object[]>>
+        > _methodCache = new();
+
+#if UNITY_2017_1_OR_NEWER
+        private readonly HashSet<MonoBehaviour> _recipientCache = new();
+        private readonly List<MonoBehaviour> _componentCache = new();
+#endif
+
         private readonly RegistrationLog _log = new();
 
         static MessageBus()
@@ -128,11 +146,6 @@
             }
         }
 
-        public MessageBus()
-        {
-            RegisteredGlobalSequentialIndex = Interlocked.Increment(ref GlobalSequentialIndex);
-        }
-
         public Action RegisterUntargeted<T>(MessageHandler messageHandler, int priority = 0)
             where T : IUntargetedMessage
         {
@@ -708,14 +721,191 @@
             }
 
             bool foundAnyHandlers = false;
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>> targetedHandlers;
+            HandlerCache<int, HandlerCache> sortedHandlers;
+
+            if (typeof(TMessage) == typeof(DxReflexiveMessage))
+            {
+#if UNITY_2017_1_OR_NEWER
+                ref DxReflexiveMessage reflexiveMessage = ref Unsafe.As<
+                    TMessage,
+                    DxReflexiveMessage
+                >(ref typedMessage);
+
+                GameObject go;
+                bool found;
+                UnityEngine.Object targetObject = target.Object;
+                switch (targetObject)
+                {
+                    case GameObject gameObject:
+                    {
+                        found = true;
+                        go = gameObject;
+                        break;
+                    }
+                    case Component component:
+                    {
+                        found = true;
+                        go = component.gameObject;
+                        break;
+                    }
+                    default:
+                    {
+                        go = null;
+                        found = false;
+                        break;
+                    }
+                }
+
+                if (found)
+                {
+                    _recipientCache.Clear();
+                    bool sentInADirection = false;
+                    if (reflexiveMessage.sendMode.HasFlagNoAlloc(ReflexiveSendMode.Upwards))
+                    {
+                        sentInADirection = true;
+                        if (
+                            !reflexiveMessage.sendMode.HasFlagNoAlloc(ReflexiveSendMode.Downwards)
+                            && !reflexiveMessage.sendMode.HasFlagNoAlloc(ReflexiveSendMode.Flat)
+                        )
+                        {
+                            switch (reflexiveMessage.parameters.Length)
+                            {
+                                case 0:
+                                {
+                                    go.SendMessageUpwards(reflexiveMessage.method);
+                                    break;
+                                }
+                                case 1:
+                                {
+                                    go.SendMessageUpwards(
+                                        reflexiveMessage.method,
+                                        reflexiveMessage.parameters[0]
+                                    );
+                                    break;
+                                }
+                                default:
+                                {
+                                    Component[] parentComponents = go.GetComponentsInParent(
+                                        typeof(MonoBehaviour),
+                                        true
+                                    );
+                                    foreach (Component component in parentComponents)
+                                    {
+                                        if (component is MonoBehaviour script)
+                                        {
+                                            SendMessage(script, ref reflexiveMessage);
+                                        }
+                                    }
+
+                                    break;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            Component[] parentComponents = go.GetComponentsInParent(
+                                typeof(MonoBehaviour)
+                            );
+                            foreach (Component component in parentComponents)
+                            {
+                                if (component is MonoBehaviour script)
+                                {
+                                    SendMessage(script, ref reflexiveMessage);
+                                }
+                            }
+                        }
+                    }
+                    if (reflexiveMessage.sendMode.HasFlagNoAlloc(ReflexiveSendMode.Downwards))
+                    {
+                        sentInADirection = true;
+                        if (
+                            !reflexiveMessage.sendMode.HasFlagNoAlloc(ReflexiveSendMode.Upwards)
+                            && !reflexiveMessage.sendMode.HasFlagNoAlloc(ReflexiveSendMode.Flat)
+                        )
+                        {
+                            switch (reflexiveMessage.parameters.Length)
+                            {
+                                case 0:
+                                {
+                                    go.BroadcastMessage(reflexiveMessage.method);
+                                    break;
+                                }
+                                case 1:
+                                {
+                                    go.BroadcastMessage(
+                                        reflexiveMessage.method,
+                                        reflexiveMessage.parameters[0]
+                                    );
+                                    break;
+                                }
+                                default:
+                                {
+                                    _componentCache.Clear();
+                                    go.GetComponentsInChildren(true, _componentCache);
+                                    foreach (MonoBehaviour parentComponent in _componentCache)
+                                    {
+                                        SendMessage(parentComponent, ref reflexiveMessage);
+                                    }
+
+                                    break;
+                                }
+                            }
+                        }
+                        else
+                        {
+                            _componentCache.Clear();
+                            go.GetComponentsInChildren(_componentCache);
+                            foreach (MonoBehaviour parentComponent in _componentCache)
+                            {
+                                SendMessage(parentComponent, ref reflexiveMessage);
+                            }
+                        }
+                    }
+                    else if (
+                        !sentInADirection
+                        && reflexiveMessage.sendMode.HasFlagNoAlloc(ReflexiveSendMode.Flat)
+                    )
+                    {
+                        switch (reflexiveMessage.parameters.Length)
+                        {
+                            case 0:
+                            {
+                                go.SendMessage(reflexiveMessage.method);
+                                break;
+                            }
+                            case 1:
+                            {
+                                go.SendMessage(
+                                    reflexiveMessage.method,
+                                    reflexiveMessage.parameters[0]
+                                );
+                                break;
+                            }
+                            default:
+                            {
+                                _componentCache.Clear();
+                                go.GetComponents(_componentCache);
+                                foreach (MonoBehaviour component in _componentCache)
+                                {
+                                    SendMessage(component, ref reflexiveMessage);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+#else
+                MessagingDebug.Log(
+                    LogLevel.Error,
+                    "Reflexive messages are not supported in this build."
+                );
+#endif
+            }
+
             if (
-                _targetedSinks.TryGetValue<TMessage>(
-                    out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> targetedHandlers
-                )
-                && targetedHandlers.TryGetValue(
-                    target,
-                    out HandlerCache<int, HandlerCache> sortedHandlers
-                )
+                _targetedSinks.TryGetValue<TMessage>(out targetedHandlers)
+                && targetedHandlers.TryGetValue(target, out sortedHandlers)
                 && 0 < sortedHandlers.handlers.Count
             )
             {
@@ -3160,5 +3350,137 @@
                 sourcedBroadcast(ref target, ref typedMessage);
             }
         }
+
+#if UNITY_2017_1_OR_NEWER
+        private static Action<MonoBehaviour, object[]> CompileMethodAction(MethodInfo methodInfo)
+        {
+            ParameterExpression componentParameter = Expression.Parameter(
+                typeof(MonoBehaviour),
+                "targetComponent"
+            );
+            ParameterExpression argsParameter = Expression.Parameter(typeof(object[]), "args");
+            ParameterInfo[] methodParams = methodInfo.GetParameters();
+
+            ArgumentExpressionsCache.Clear();
+            for (int i = 0; i < methodParams.Length; ++i)
+            {
+                Expression indexAccess = Expression.ArrayIndex(
+                    argsParameter,
+                    Expression.Constant(i)
+                );
+                Expression convertedArg = Expression.Convert(
+                    indexAccess,
+                    methodParams[i].ParameterType
+                );
+                ArgumentExpressionsCache.Add(convertedArg);
+            }
+
+            // ReSharper disable once AssignNullToNotNullAttribute
+            Expression instanceExpression = methodInfo.IsStatic
+                ? null
+                : Expression.Convert(componentParameter, methodInfo.DeclaringType);
+            MethodCallExpression callExpression = Expression.Call(
+                instanceExpression,
+                methodInfo,
+                ArgumentExpressionsCache
+            );
+            Expression<Action<MonoBehaviour, object[]>> lambda = Expression.Lambda<
+                Action<MonoBehaviour, object[]>
+            >(callExpression, componentParameter, argsParameter);
+
+            return lambda.Compile();
+        }
+#endif
+
+        private void SendMessage(MonoBehaviour recipient, ref DxReflexiveMessage message)
+        {
+            if (!_recipientCache.Add(recipient))
+            {
+                return;
+            }
+
+            Type componentType = recipient.GetType();
+            if (
+                !_methodCache.TryGetValue(
+                    componentType,
+                    out Dictionary<MethodSignatureKey, Action<MonoBehaviour, object[]>> methodCache
+                )
+            )
+            {
+                _methodCache[componentType] = methodCache =
+                    new Dictionary<MethodSignatureKey, Action<MonoBehaviour, object[]>>();
+            }
+
+            MethodSignatureKey lookupKey = message.signatureKey;
+            if (!methodCache.TryGetValue(lookupKey, out Action<MonoBehaviour, object[]> method))
+            {
+                MethodInfo methodInfo = null;
+                try
+                {
+                    methodInfo = componentType.GetMethod(
+                        message.method,
+                        ReflexiveMethodBindingFlags,
+                        null,
+                        message.parameterTypes,
+                        null
+                    );
+                }
+                catch (AmbiguousMatchException)
+                {
+                    MethodInfo[] matchingMethods = componentType.GetMethods(
+                        ReflexiveMethodBindingFlags
+                    );
+                    foreach (MethodInfo matchingMethod in matchingMethods)
+                    {
+                        if (
+                            !string.Equals(
+                                matchingMethod.Name,
+                                message.method,
+                                StringComparison.Ordinal
+                            )
+                            || !ParameterTypesMatch(
+                                matchingMethod.GetParameters(),
+                                message.parameterTypes
+                            )
+                        )
+                        {
+                            continue;
+                        }
+
+                        methodInfo = matchingMethod;
+                        break;
+                    }
+                }
+                catch
+                {
+                    methodInfo = null;
+                }
+
+                if (methodInfo != null)
+                {
+                    method = CompileMethodAction(methodInfo);
+                }
+                methodCache[lookupKey] = method;
+            }
+
+            method?.Invoke(recipient, message.parameters);
+        }
+
+        private static bool ParameterTypesMatch(ParameterInfo[] methodParams, Type[] expectedTypes)
+        {
+            if (methodParams.Length != expectedTypes.Length)
+            {
+                return false;
+            }
+
+            for (int i = 0; i < methodParams.Length; ++i)
+            {
+                if (methodParams[i].ParameterType != expectedTypes[i])
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
     }
 }

package/Runtime/Core/Messages/DxReflexiveMessage.cs

@@ -0,0 +1,132 @@
+namespace DxMessaging.Core.Messages
+{
+    using System;
+    using Attributes;
+
+    [Flags]
+    public enum ReflexiveSendMode
+    {
+        [Obsolete("Please use a valid Send Mode")]
+        None = 0,
+        Flat = 1 << 0,
+        Downwards = 1 << 1,
+        Upwards = 1 << 2,
+    }
+
+    public readonly struct MethodSignatureKey : IEquatable<MethodSignatureKey>
+    {
+        private const int HashBase = 5556137;
+        private const int HashMultiplier = 95785853;
+
+        private readonly string _methodName;
+        private readonly Type[] _parameterTypes;
+
+        private readonly int _hashCode;
+
+        public MethodSignatureKey(string methodName, Type[] parameterTypes)
+            : this()
+        {
+            _methodName = methodName ?? throw new ArgumentNullException(nameof(methodName));
+            _parameterTypes = parameterTypes;
+            _hashCode = CalculateHashCode();
+        }
+
+        private int CalculateHashCode()
+        {
+            int hashCode = HashBase + _methodName.GetHashCode();
+            foreach (Type type in _parameterTypes)
+            {
+                hashCode = hashCode * HashMultiplier + type.GetHashCode();
+            }
+
+            return hashCode;
+        }
+
+        public override int GetHashCode()
+        {
+            return _hashCode;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is MethodSignatureKey other && Equals(other);
+        }
+
+        public bool Equals(MethodSignatureKey other)
+        {
+            if (
+                _parameterTypes.Length != other._parameterTypes.Length
+                || _methodName != other._methodName
+            )
+            {
+                return false;
+            }
+
+            // ReSharper disable once LoopCanBeConvertedToQuery
+            for (int i = 0; i < _parameterTypes.Length; ++i)
+            {
+                if (_parameterTypes[i] != other._parameterTypes[i])
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static bool operator ==(MethodSignatureKey left, MethodSignatureKey right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(MethodSignatureKey left, MethodSignatureKey right)
+        {
+            return !(left == right);
+        }
+    }
+
+    [DxTargetedMessage]
+    public readonly partial struct DxReflexiveMessage
+    {
+        public readonly string method;
+        public readonly ReflexiveSendMode sendMode;
+        public readonly object[] parameters;
+
+        public readonly Type[] parameterTypes;
+
+        public readonly MethodSignatureKey signatureKey;
+
+        public DxReflexiveMessage(
+            string method,
+            ReflexiveSendMode sendMode,
+            params object[] parameters
+        )
+        {
+            this.method = method;
+            this.sendMode = sendMode;
+            this.parameters = parameters;
+
+            if (0 < parameters.Length)
+            {
+                int parameterCount = parameters.Length;
+                parameterTypes = new Type[parameterCount];
+                for (int i = 0; i < parameterCount; i++)
+                {
+                    object parameter = parameters[i];
+                    if (parameter == null)
+                    {
+                        throw new ArgumentNullException(
+                            $"Parameter at index {i} is null, cannot resolve type!"
+                        );
+                    }
+                    parameterTypes[i] = parameter.GetType();
+                }
+            }
+            else
+            {
+                parameterTypes = Array.Empty<Type>();
+            }
+            signatureKey = new MethodSignatureKey(method, parameterTypes);
+        }
+    }
+}

package/Runtime/Core/Messages/DxReflexiveMessage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f9a83f6bf3c0487f9e5cff498dbb6932
+timeCreated: 1745161955

package/Runtime/Core/MessagingDebug.cs

@@ -46,7 +46,7 @@
         /// </note>
         /// <param name="logLevel">Severity of the message.</param>
         /// <param name="message">Format string.</param>
-        /// <param name="args">Args to populate format string with.</param>
+        /// <param name="args">Args to populate the format string with.</param>
         public static void Log(LogLevel logLevel, string message, params object[] args)
         {
             if (!enabled)

package/Runtime/Unity/MessageAwareComponent.cs

@@ -1,39 +1,45 @@
 namespace DxMessaging.Unity
 {
     using Core;
+    using Messages;
     using UnityEngine;
 
     [RequireComponent(typeof(MessagingComponent))]
     public abstract class MessageAwareComponent : MonoBehaviour
     {
+        public virtual MessageRegistrationToken Token => _messageRegistrationToken;
+
         protected MessageRegistrationToken _messageRegistrationToken;
 
         /// <summary>
-        ///     If true, will register/un-register handles when the component is enabled or disabled.
+        ///     If true, will register/unregister handles when the component is enabled or disabled.
         /// </summary>
         protected virtual bool MessageRegistrationTiedToEnableStatus => true;
 
         protected bool _isQuitting;
 
-        protected virtual void Awake()
-        {
-            SetupMessageHandlers();
-        }
+        protected MessagingComponent _messagingComponent;
 
-        protected void SetupMessageHandlers()
+        protected virtual void Awake()
         {
-            if (_messageRegistrationToken == null)
-            {
-                MessagingComponent messenger = GetComponent<MessagingComponent>();
-                _messageRegistrationToken = messenger.Create(this);
-            }
-
+            _messagingComponent = GetComponent<MessagingComponent>();
+            _messageRegistrationToken = _messagingComponent.Create(this);
             RegisterMessageHandlers();
         }
 
         protected virtual void RegisterMessageHandlers()
         {
-            // No-op, expectation is that implementations implement their own logic here
+            _ = _messageRegistrationToken.RegisterGameObjectTargeted<StringMessage>(
+                gameObject,
+                HandleStringGameObjectMessage
+            );
+            _ = _messageRegistrationToken.RegisterComponentTargeted<StringMessage>(
+                this,
+                HandleStringComponentMessage
+            );
+            _ = _messageRegistrationToken.RegisterUntargeted<GlobalStringMessage>(
+                HandleGlobalStringMessage
+            );
         }
 
         protected virtual void OnEnable()
@@ -72,5 +78,20 @@
         {
             _isQuitting = true;
         }
+
+        protected virtual void HandleStringGameObjectMessage(ref StringMessage message)
+        {
+            // No-op by default
+        }
+
+        protected virtual void HandleStringComponentMessage(ref StringMessage message)
+        {
+            // No-op by default
+        }
+
+        protected virtual void HandleGlobalStringMessage(ref GlobalStringMessage message)
+        {
+            // No-op by default
+        }
     }
 }

package/Runtime/Unity/Messages/GlobalStringMessage.cs

@@ -0,0 +1,15 @@
+namespace DxMessaging.Unity.Messages
+{
+    using Core.Attributes;
+
+    [DxUntargetedMessage]
+    public readonly partial struct GlobalStringMessage
+    {
+        public readonly string message;
+
+        public GlobalStringMessage(string message)
+        {
+            this.message = message;
+        }
+    }
+}

package/Runtime/Unity/Messages/GlobalStringMessage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 58b2b780f9844aeb8929eeca855ba3be
+timeCreated: 1745161506

package/Runtime/Unity/Messages/StringMessage.cs

@@ -0,0 +1,15 @@
+namespace DxMessaging.Unity.Messages
+{
+    using Core.Attributes;
+
+    [DxTargetedMessage]
+    public readonly partial struct StringMessage
+    {
+        public readonly string message;
+
+        public StringMessage(string message)
+        {
+            this.message = message;
+        }
+    }
+}

package/Runtime/Unity/Messages/StringMessage.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cf8206ca4c8449a8b8e112ad25554f1f
+timeCreated: 1745161457

package/Runtime/Unity/Messages.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f1a132a737bb42a79205b2269554e818
+timeCreated: 1745160607

package/Runtime/WallstopStudios.DxMessaging.asmdef

@@ -4,7 +4,7 @@
     "references": [],
     "includePlatforms": [],
     "excludePlatforms": [],
-    "allowUnsafeCode": false,
+    "allowUnsafeCode": true,
     "overrideReferences": false,
     "precompiledReferences": [
         "System.Runtime.CompilerServices.Unsafe.dll"

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-rc22",
+  "version": "2.0.0-rc23",
   "displayName": "DxMessaging",
   "description": "Synchronous Event Bus for Unity",
   "unity": "2021.3",