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

package/Runtime/Core/MessageBus/MessageBus.cs

@@ -2,9 +2,16 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Linq.Expressions;
     using System.Reflection;
+    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.
@@ -34,13 +41,15 @@
                 int count = 0;
                 foreach (var entry in _targetedSinks)
                 {
-                    count += entry.Value.Count;
+                    count += entry.Count;
                 }
 
                 return count;
             }
         }
 
+        public int RegisteredGlobalSequentialIndex { get; } = GenerateNewGlobalSequentialIndex();
+
         public int RegisteredBroadcast
         {
             get
@@ -48,7 +57,7 @@
                 int count = 0;
                 foreach (var entry in _broadcastSinks)
                 {
-                    count += entry.Value.Count;
+                    count += entry.Count;
                 }
 
                 return count;
@@ -62,7 +71,7 @@
                 int count = 0;
                 foreach (var entry in _sinks)
                 {
-                    count += entry.Value.handlers.Count;
+                    count += entry.handlers.Count;
                 }
 
                 return count;
@@ -73,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;
@@ -86,44 +98,54 @@
 
         public RegistrationLog Log => _log;
 
-        private readonly Dictionary<Type, HandlerCache<int, HandlerCache>> _sinks = new();
-        private readonly Dictionary<
-            Type,
+        private readonly MessageCache<HandlerCache<int, HandlerCache>> _sinks = new();
+        private readonly MessageCache<
             Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
         > _targetedSinks = new();
-        private readonly Dictionary<
-            Type,
+        private readonly MessageCache<
             Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
         > _broadcastSinks = new();
-        private readonly Dictionary<Type, HandlerCache<int, HandlerCache>> _postProcessingSinks =
-            new();
-        private readonly Dictionary<
-            Type,
+        private readonly MessageCache<HandlerCache<int, HandlerCache>> _postProcessingSinks = new();
+        private readonly MessageCache<
             Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
         > _postProcessingTargetedSinks = new();
-        private readonly Dictionary<
-            Type,
+        private readonly MessageCache<
             Dictionary<InstanceId, HandlerCache<int, HandlerCache>>
         > _postProcessingBroadcastSinks = new();
-        private readonly Dictionary<
-            Type,
+        private readonly MessageCache<
             HandlerCache<int, HandlerCache>
         > _postProcessingTargetedWithoutTargetingSinks = new();
-        private readonly Dictionary<
-            Type,
+        private readonly MessageCache<
             HandlerCache<int, HandlerCache>
         > _postProcessingBroadcastWithoutSourceSinks = new();
         private readonly HandlerCache _globalSinks = new();
-        private readonly Dictionary<Type, HandlerCache<int, List<object>>> _interceptsByType =
-            new();
+        private readonly MessageCache<HandlerCache<int, List<object>>> _interceptsByType = new();
         private readonly Dictionary<object, Dictionary<int, int>> _uniqueInterceptorsAndPriorities =
             new();
 
         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()
+        {
+            if (!DxMessagingRuntime.Initialized)
+            {
+                DxMessagingRuntime.Initialize();
+            }
+        }
+
         public Action RegisterUntargeted<T>(MessageHandler messageHandler, int priority = 0)
             where T : IUntargetedMessage
         {
@@ -352,16 +374,8 @@
             where T : IMessage
         {
             Type type = typeof(T);
-            if (
-                !_interceptsByType.TryGetValue(
-                    type,
-                    out HandlerCache<int, List<object>> prioritizedInterceptors
-                )
-            )
-            {
-                prioritizedInterceptors = new HandlerCache<int, List<object>>();
-                _interceptsByType[type] = prioritizedInterceptors;
-            }
+            HandlerCache<int, List<object>> prioritizedInterceptors =
+                _interceptsByType.GetOrAdd<T>();
 
             if (
                 !prioritizedInterceptors.handlers.TryGetValue(
@@ -446,7 +460,7 @@
                 bool complete = false;
                 if (removed)
                 {
-                    if (_interceptsByType.TryGetValue(type, out prioritizedInterceptors))
+                    if (_interceptsByType.TryGetValue<T>(out prioritizedInterceptors))
                     {
                         prioritizedInterceptors.version++;
                         if (
@@ -499,8 +513,7 @@
         public void UntargetedBroadcast<TMessage>(ref TMessage typedMessage)
             where TMessage : IUntargetedMessage
         {
-            Type type = typeof(TMessage);
-            if (!RunUntargetedInterceptors(type, ref typedMessage))
+            if (!RunUntargetedInterceptors(ref typedMessage))
             {
                 return;
             }
@@ -511,11 +524,10 @@
                 BroadcastGlobalUntargeted(ref untargetedMessage);
             }
 
-            bool foundAnyHandlers = InternalUntargetedBroadcast(ref typedMessage, type);
+            bool foundAnyHandlers = InternalUntargetedBroadcast(ref typedMessage);
 
             if (
-                _postProcessingSinks.TryGetValue(
-                    type,
+                _postProcessingSinks.TryGetValue<TMessage>(
                     out HandlerCache<int, HandlerCache> sortedHandlers
                 )
                 && 0 < sortedHandlers.handlers.Count
@@ -697,8 +709,7 @@
         public void TargetedBroadcast<TMessage>(ref InstanceId target, ref TMessage typedMessage)
             where TMessage : ITargetedMessage
         {
-            Type type = typeof(TMessage);
-            if (!RunTargetedInterceptors(type, ref typedMessage, ref target))
+            if (!RunTargetedInterceptors(ref typedMessage, ref target))
             {
                 return;
             }
@@ -710,15 +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(
-                    type,
-                    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
             )
             {
@@ -795,10 +982,10 @@
                 }
             }
 
-            _ = InternalTargetedWithoutTargetingBroadcast(ref target, ref typedMessage, type);
+            _ = InternalTargetedWithoutTargetingBroadcast(ref target, ref typedMessage);
 
             if (
-                _postProcessingTargetedSinks.TryGetValue(type, out targetedHandlers)
+                _postProcessingTargetedSinks.TryGetValue<TMessage>(out targetedHandlers)
                 && targetedHandlers.TryGetValue(target, out sortedHandlers)
                 && 0 < sortedHandlers.handlers.Count
             )
@@ -952,7 +1139,9 @@
             }
 
             if (
-                _postProcessingTargetedWithoutTargetingSinks.TryGetValue(type, out sortedHandlers)
+                _postProcessingTargetedWithoutTargetingSinks.TryGetValue<TMessage>(
+                    out sortedHandlers
+                )
                 && 0 < sortedHandlers.handlers.Count
             )
             {
@@ -1435,8 +1624,7 @@
         public void SourcedBroadcast<TMessage>(ref InstanceId source, ref TMessage typedMessage)
             where TMessage : IBroadcastMessage
         {
-            Type type = typeof(TMessage);
-            if (!RunBroadcastInterceptors(type, ref typedMessage, ref source))
+            if (!RunBroadcastInterceptors(ref typedMessage, ref source))
             {
                 return;
             }
@@ -1449,8 +1637,7 @@
 
             bool foundAnyHandlers = false;
             if (
-                _broadcastSinks.TryGetValue(
-                    type,
+                _broadcastSinks.TryGetValue<TMessage>(
                     out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> broadcastHandlers
                 )
                 && broadcastHandlers.TryGetValue(
@@ -1528,10 +1715,10 @@
                 }
             }
 
-            _ = InternalBroadcastWithoutSource(ref source, ref typedMessage, type);
+            _ = InternalBroadcastWithoutSource(ref source, ref typedMessage);
 
             if (
-                _postProcessingBroadcastSinks.TryGetValue(type, out broadcastHandlers)
+                _postProcessingBroadcastSinks.TryGetValue<TMessage>(out broadcastHandlers)
                 && broadcastHandlers.TryGetValue(source, out sortedHandlers)
                 && 0 < sortedHandlers.handlers.Count
             )
@@ -1685,7 +1872,7 @@
             }
 
             if (
-                _postProcessingBroadcastWithoutSourceSinks.TryGetValue(type, out sortedHandlers)
+                _postProcessingBroadcastWithoutSourceSinks.TryGetValue<TMessage>(out sortedHandlers)
                 && 0 < sortedHandlers.handlers.Count
             )
             {
@@ -2138,15 +2325,14 @@
             }
         }
 
-        private bool TryGetInterceptorCaches(
-            Type type,
+        private bool TryGetInterceptorCaches<TMessage>(
             out List<KeyValuePair<int, List<object>>> interceptorStack,
             out List<object> interceptorObjects
         )
+            where TMessage : IMessage
         {
             if (
-                !_interceptsByType.TryGetValue(
-                    type,
+                !_interceptsByType.TryGetValue<TMessage>(
                     out HandlerCache<int, List<object>> interceptors
                 )
                 || interceptors.handlers.Count == 0
@@ -2179,12 +2365,11 @@
             return true;
         }
 
-        private bool RunUntargetedInterceptors<T>(Type type, ref T message)
+        private bool RunUntargetedInterceptors<T>(ref T message)
             where T : IUntargetedMessage
         {
             if (
-                !TryGetInterceptorCaches(
-                    type,
+                !TryGetInterceptorCaches<T>(
                     out List<KeyValuePair<int, List<object>>> interceptorStack,
                     out List<object> interceptorObjects
                 )
@@ -2225,12 +2410,11 @@
             return true;
         }
 
-        private bool RunTargetedInterceptors<T>(Type type, ref T message, ref InstanceId target)
+        private bool RunTargetedInterceptors<T>(ref T message, ref InstanceId target)
             where T : ITargetedMessage
         {
             if (
-                !TryGetInterceptorCaches(
-                    type,
+                !TryGetInterceptorCaches<T>(
                     out List<KeyValuePair<int, List<object>>> interceptorStack,
                     out List<object> interceptorObjects
                 )
@@ -2271,12 +2455,11 @@
             return true;
         }
 
-        private bool RunBroadcastInterceptors<T>(Type type, ref T message, ref InstanceId source)
+        private bool RunBroadcastInterceptors<T>(ref T message, ref InstanceId source)
             where T : IBroadcastMessage
         {
             if (
-                !TryGetInterceptorCaches(
-                    type,
+                !TryGetInterceptorCaches<T>(
                     out List<KeyValuePair<int, List<object>>> interceptorStack,
                     out List<object> interceptorObjects
                 )
@@ -2317,11 +2500,11 @@
             return true;
         }
 
-        private bool InternalUntargetedBroadcast<TMessage>(ref TMessage message, Type type)
+        private bool InternalUntargetedBroadcast<TMessage>(ref TMessage message)
             where TMessage : IMessage
         {
             if (
-                !_sinks.TryGetValue(type, out HandlerCache<int, HandlerCache> sortedHandlers)
+                !_sinks.TryGetValue<TMessage>(out HandlerCache<int, HandlerCache> sortedHandlers)
                 || sortedHandlers.handlers.Count == 0
             )
             {
@@ -2452,13 +2635,12 @@
 
         private bool InternalTargetedWithoutTargetingBroadcast<TMessage>(
             ref InstanceId target,
-            ref TMessage message,
-            Type type
+            ref TMessage message
         )
             where TMessage : ITargetedMessage
         {
             if (
-                !_sinks.TryGetValue(type, out HandlerCache<int, HandlerCache> sortedHandlers)
+                !_sinks.TryGetValue<TMessage>(out HandlerCache<int, HandlerCache> sortedHandlers)
                 || sortedHandlers.handlers.Count == 0
             )
             {
@@ -2607,13 +2789,12 @@
 
         private bool InternalBroadcastWithoutSource<TMessage>(
             ref InstanceId source,
-            ref TMessage message,
-            Type type
+            ref TMessage message
         )
             where TMessage : IBroadcastMessage
         {
             if (
-                !_sinks.TryGetValue(type, out HandlerCache<int, HandlerCache> sortedHandlers)
+                !_sinks.TryGetValue<TMessage>(out HandlerCache<int, HandlerCache> sortedHandlers)
                 || sortedHandlers.handlers.Count == 0
             )
             {
@@ -2841,7 +3022,7 @@
 
         private Action InternalRegisterUntargeted<T>(
             MessageHandler messageHandler,
-            Dictionary<Type, HandlerCache<int, HandlerCache>> sinks,
+            MessageCache<HandlerCache<int, HandlerCache>> sinks,
             RegistrationMethod registrationMethod,
             int priority
         )
@@ -2855,11 +3036,7 @@
             InstanceId handlerOwnerId = messageHandler.owner;
             Type type = typeof(T);
 
-            if (!sinks.TryGetValue(type, out HandlerCache<int, HandlerCache> handlers))
-            {
-                handlers = new HandlerCache<int, HandlerCache>();
-                sinks[type] = handlers;
-            }
+            HandlerCache<int, HandlerCache> handlers = sinks.GetOrAdd<T>();
 
             if (!handlers.handlers.TryGetValue(priority, out HandlerCache cache))
             {
@@ -2894,7 +3071,7 @@
                     )
                 );
                 if (
-                    !sinks.TryGetValue(type, out handlers)
+                    !sinks.TryGetValue<T>(out handlers)
                     || !handlers.handlers.TryGetValue(priority, out cache)
                     || !cache.handlers.TryGetValue(messageHandler, out count)
                 )
@@ -2925,7 +3102,7 @@
 
                     if (handlers.handlers.Count == 0)
                     {
-                        _ = sinks.Remove(type);
+                        sinks.Remove<T>();
                     }
 
                     if (!complete && MessagingDebug.enabled)
@@ -2948,10 +3125,11 @@
         private Action InternalRegisterWithContext<T>(
             InstanceId context,
             MessageHandler messageHandler,
-            Dictionary<Type, Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> sinks,
+            MessageCache<Dictionary<InstanceId, HandlerCache<int, HandlerCache>>> sinks,
             RegistrationMethod registrationMethod,
             int priority
         )
+            where T : IMessage
         {
             if (messageHandler == null)
             {
@@ -2959,16 +3137,8 @@
             }
 
             Type type = typeof(T);
-            if (
-                !sinks.TryGetValue(
-                    type,
-                    out Dictionary<InstanceId, HandlerCache<int, HandlerCache>> broadcastHandlers
-                )
-            )
-            {
-                broadcastHandlers = new Dictionary<InstanceId, HandlerCache<int, HandlerCache>>();
-                sinks[type] = broadcastHandlers;
-            }
+            Dictionary<InstanceId, HandlerCache<int, HandlerCache>> broadcastHandlers =
+                sinks.GetOrAdd<T>();
 
             if (
                 !broadcastHandlers.TryGetValue(
@@ -3014,7 +3184,7 @@
                     )
                 );
                 if (
-                    !sinks.TryGetValue(type, out broadcastHandlers)
+                    !sinks.TryGetValue<T>(out broadcastHandlers)
                     || !broadcastHandlers.TryGetValue(context, out handlers)
                     || !handlers.handlers.TryGetValue(priority, out cache)
                     || !cache.handlers.TryGetValue(messageHandler, out count)
@@ -3050,7 +3220,7 @@
 
                     if (broadcastHandlers.Count == 0)
                     {
-                        _ = sinks.Remove(type);
+                        sinks.Remove<T>();
                     }
 
                     if (!complete && MessagingDebug.enabled)
@@ -3180,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;
+        }
     }
 }