com.wallstop-studios.unity-helpers 2.0.0-rc79.4 → 2.0.0-rc79.6

package/Runtime/Core/Helper/ReflectionHelpers.cs

@@ -1,25 +1,44 @@
 #if !((UNITY_WEBGL && !UNITY_EDITOR) || ENABLE_IL2CPP)
 #define EMIT_DYNAMIC_IL
+#define SUPPORT_EXPRESSION_COMPILE
 #endif
 
 namespace WallstopStudios.UnityHelpers.Core.Helper
 {
     using System;
     using System.Collections;
+    using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Linq.Expressions;
     using System.Reflection;
     using System.Reflection.Emit;
     using System.Runtime.CompilerServices;
-    using Extension;
 
     public delegate void FieldSetter<TInstance, in TValue>(ref TInstance instance, TValue value);
 
     public static class ReflectionHelpers
     {
-        private static readonly Dictionary<Type, Func<int, Array>> ArrayCreators = new();
-        private static readonly Dictionary<Type, Func<IList>> ListCreators = new();
-        private static readonly Dictionary<Type, Func<int, IList>> ListWithCapacityCreators = new();
+        private static readonly ConcurrentDictionary<Type, Func<int, Array>> ArrayCreators = new();
+        private static readonly ConcurrentDictionary<Type, Func<IList>> ListCreators = new();
+        private static readonly ConcurrentDictionary<
+            Type,
+            Func<int, IList>
+        > ListWithCapacityCreators = new();
+        private static readonly ConcurrentDictionary<
+            MethodInfo,
+            Func<object, object[], object>
+        > MethodInvokers = new();
+        private static readonly ConcurrentDictionary<
+            MethodInfo,
+            Func<object[], object>
+        > StaticMethodInvokers = new();
+        private static readonly ConcurrentDictionary<
+            ConstructorInfo,
+            Func<object[], object>
+        > Constructors = new();
+
+        private static readonly bool CanCompileExpressions = CheckExpressionCompilationSupport();
 
         public static bool IsAttributeDefined<T>(
             this ICustomAttributeProvider provider,
@@ -30,10 +49,17 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
         {
             try
             {
-                if (provider.IsDefined(typeof(T), inherit))
+                Type type = typeof(T);
+                if (provider.IsDefined(type, inherit))
                 {
-                    attribute = (T)provider.GetCustomAttributes(typeof(T), inherit)[0];
-                    return true;
+                    object[] attributes = provider.GetCustomAttributes(type, inherit);
+                    if (attributes.Length == 0)
+                    {
+                        attribute = default;
+                        return false;
+                    }
+                    attribute = attributes[0] as T;
+                    return attribute != null;
                 }
             }
             catch
@@ -96,7 +122,7 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
         public static Func<object, object> GetFieldGetter(FieldInfo field)
         {
 #if !EMIT_DYNAMIC_IL
-            return field.GetValue;
+            return CreateCompiledFieldGetter(field);
 #else
             DynamicMethod dynamicMethod = new(
                 $"Get{field.DeclaringType.Name}_{field.Name}",
@@ -130,7 +156,7 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
         public static Func<object, object> GetPropertyGetter(PropertyInfo property)
         {
 #if !EMIT_DYNAMIC_IL
-            return property.GetValue;
+            return CreateCompiledPropertyGetter(property);
 #else
             MethodInfo getMethod = property.GetGetMethod(true);
 
@@ -143,15 +169,25 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
             );
 
             ILGenerator il = dynamicMethod.GetILGenerator();
-            il.Emit(OpCodes.Ldarg_0);
-            il.Emit(
-                property.DeclaringType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass,
-                property.DeclaringType
-            );
-            il.Emit(
-                property.DeclaringType.IsValueType ? OpCodes.Call : OpCodes.Callvirt,
-                getMethod
-            );
+
+            if (getMethod.IsStatic)
+            {
+                // For static properties, don't load any arguments
+                il.Emit(OpCodes.Call, getMethod);
+            }
+            else
+            {
+                // For instance properties, load and cast the argument
+                il.Emit(OpCodes.Ldarg_0);
+                il.Emit(
+                    property.DeclaringType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass,
+                    property.DeclaringType
+                );
+                il.Emit(
+                    property.DeclaringType.IsValueType ? OpCodes.Call : OpCodes.Callvirt,
+                    getMethod
+                );
+            }
 
             if (property.PropertyType.IsValueType)
             {
@@ -172,7 +208,7 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
             }
 
 #if !EMIT_DYNAMIC_IL
-            return () => field.GetValue(null);
+            return CreateCompiledStaticFieldGetter(field);
 #else
             DynamicMethod dynamicMethod = new(
                 $"Get{field.DeclaringType.Name}_{field.Name}",
@@ -279,7 +315,7 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
                 // Use null for instance, null for indexer args for static properties
                 return (TValue)property.GetValue(null, null);
             }
-#endif
+#else
             DynamicMethod dynamicMethod = new(
                 $"GetStatic_{property.DeclaringType.Name}_{property.Name}",
                 typeof(TValue),
@@ -316,6 +352,7 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
 
             il.Emit(OpCodes.Ret);
             return (Func<TValue>)dynamicMethod.CreateDelegate(typeof(Func<TValue>));
+#endif
         }
 
         public static Func<TValue> GetStaticFieldGetter<TValue>(FieldInfo field)
@@ -446,7 +483,7 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
         public static Action<object, object> GetFieldSetter(FieldInfo field)
         {
 #if !EMIT_DYNAMIC_IL
-            return field.SetValue;
+            return CreateCompiledFieldSetter(field);
 #else
             DynamicMethod dynamicMethod = new(
                 $"SetField{field.DeclaringType.Name}_{field.Name}",
@@ -483,7 +520,7 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
                 throw new ArgumentException(nameof(field));
             }
 #if !EMIT_DYNAMIC_IL
-            return value => field.SetValue(null, value);
+            return CreateCompiledStaticFieldSetter(field);
 #else
             DynamicMethod dynamicMethod = new(
                 $"SetFieldStatic{field.DeclaringType.Name}_{field.Name}",
@@ -586,5 +623,1314 @@ namespace WallstopStudios.UnityHelpers.Core.Helper
             return (Func<int, IList>)dynamicMethod.CreateDelegate(typeof(Func<int, IList>));
 #endif
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static object InvokeMethod(
+            MethodInfo method,
+            object instance,
+            params object[] parameters
+        )
+        {
+            return MethodInvokers
+                .GetOrAdd(method, methodInfo => GetMethodInvoker(methodInfo))
+                .Invoke(instance, parameters);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static object InvokeStaticMethod(MethodInfo method, params object[] parameters)
+        {
+            return StaticMethodInvokers
+                .GetOrAdd(method, methodInfo => GetStaticMethodInvoker(methodInfo))
+                .Invoke(parameters);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static object CreateInstance(ConstructorInfo constructor, params object[] parameters)
+        {
+            return Constructors
+                .GetOrAdd(constructor, ctor => GetConstructor(ctor))
+                .Invoke(parameters);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T CreateInstance<T>(params object[] parameters)
+        {
+            Type type = typeof(T);
+            Type[] parameterTypes =
+                parameters?.Select(p => p?.GetType()).ToArray() ?? Type.EmptyTypes;
+            ConstructorInfo constructor = type.GetConstructor(parameterTypes);
+            if (constructor == null)
+            {
+                throw new ArgumentException($"No matching constructor found for type {type.Name}");
+            }
+            return (T)CreateInstance(constructor, parameters);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T CreateGenericInstance<T>(
+            Type genericTypeDefinition,
+            Type[] genericArguments,
+            params object[] parameters
+        )
+        {
+            Type constructedType = genericTypeDefinition.MakeGenericType(genericArguments);
+            Type[] parameterTypes =
+                parameters?.Select(p => p?.GetType()).ToArray() ?? Type.EmptyTypes;
+            ConstructorInfo constructor = constructedType.GetConstructor(parameterTypes);
+            if (constructor == null)
+            {
+                throw new ArgumentException(
+                    $"No matching constructor found for type {constructedType.Name}"
+                );
+            }
+            return (T)CreateInstance(constructor, parameters);
+        }
+
+        public static Func<object, object[], object> GetMethodInvoker(MethodInfo method)
+        {
+            if (method.IsStatic)
+            {
+                throw new ArgumentException(
+                    "Use GetStaticMethodInvoker for static methods",
+                    nameof(method)
+                );
+            }
+
+#if !EMIT_DYNAMIC_IL
+            return CreateCompiledMethodInvoker(method);
+#else
+            DynamicMethod dynamicMethod = new(
+                $"Invoke{method.DeclaringType.Name}_{method.Name}",
+                typeof(object),
+                new[] { typeof(object), typeof(object[]) },
+                method.DeclaringType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            ParameterInfo[] parameters = method.GetParameters();
+
+            il.Emit(OpCodes.Ldarg_0);
+            il.Emit(
+                method.DeclaringType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass,
+                method.DeclaringType
+            );
+
+            for (int i = 0; i < parameters.Length; i++)
+            {
+                il.Emit(OpCodes.Ldarg_1);
+                il.Emit(OpCodes.Ldc_I4, i);
+                il.Emit(OpCodes.Ldelem_Ref);
+
+                Type paramType = parameters[i].ParameterType;
+                if (paramType.IsValueType)
+                {
+                    il.Emit(OpCodes.Unbox_Any, paramType);
+                }
+                else
+                {
+                    il.Emit(OpCodes.Castclass, paramType);
+                }
+            }
+
+            il.Emit(method.DeclaringType.IsValueType ? OpCodes.Call : OpCodes.Callvirt, method);
+
+            if (method.ReturnType == typeof(void))
+            {
+                il.Emit(OpCodes.Ldnull);
+            }
+            else if (method.ReturnType.IsValueType)
+            {
+                il.Emit(OpCodes.Box, method.ReturnType);
+            }
+
+            il.Emit(OpCodes.Ret);
+
+            return (Func<object, object[], object>)
+                dynamicMethod.CreateDelegate(typeof(Func<object, object[], object>));
+#endif
+        }
+
+        public static Func<object[], object> GetStaticMethodInvoker(MethodInfo method)
+        {
+            if (!method.IsStatic)
+            {
+                throw new ArgumentException("Method must be static", nameof(method));
+            }
+
+#if !EMIT_DYNAMIC_IL
+            return CreateCompiledStaticMethodInvoker(method);
+#else
+            DynamicMethod dynamicMethod = new(
+                $"InvokeStatic{method.DeclaringType.Name}_{method.Name}",
+                typeof(object),
+                new[] { typeof(object[]) },
+                method.DeclaringType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            ParameterInfo[] parameters = method.GetParameters();
+
+            for (int i = 0; i < parameters.Length; i++)
+            {
+                il.Emit(OpCodes.Ldarg_0);
+                il.Emit(OpCodes.Ldc_I4, i);
+                il.Emit(OpCodes.Ldelem_Ref);
+
+                Type paramType = parameters[i].ParameterType;
+                if (paramType.IsValueType)
+                {
+                    il.Emit(OpCodes.Unbox_Any, paramType);
+                }
+                else
+                {
+                    il.Emit(OpCodes.Castclass, paramType);
+                }
+            }
+
+            il.Emit(OpCodes.Call, method);
+
+            if (method.ReturnType == typeof(void))
+            {
+                il.Emit(OpCodes.Ldnull);
+            }
+            else if (method.ReturnType.IsValueType)
+            {
+                il.Emit(OpCodes.Box, method.ReturnType);
+            }
+
+            il.Emit(OpCodes.Ret);
+
+            return (Func<object[], object>)
+                dynamicMethod.CreateDelegate(typeof(Func<object[], object>));
+#endif
+        }
+
+        public static Func<object[], object> GetConstructor(ConstructorInfo constructor)
+        {
+#if !EMIT_DYNAMIC_IL
+            return CreateCompiledConstructor(constructor);
+#else
+            DynamicMethod dynamicMethod = new(
+                $"Create{constructor.DeclaringType.Name}",
+                typeof(object),
+                new[] { typeof(object[]) },
+                constructor.DeclaringType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            ParameterInfo[] parameters = constructor.GetParameters();
+
+            for (int i = 0; i < parameters.Length; i++)
+            {
+                il.Emit(OpCodes.Ldarg_0);
+                il.Emit(OpCodes.Ldc_I4, i);
+                il.Emit(OpCodes.Ldelem_Ref);
+
+                Type paramType = parameters[i].ParameterType;
+                if (paramType.IsValueType)
+                {
+                    il.Emit(OpCodes.Unbox_Any, paramType);
+                }
+                else
+                {
+                    il.Emit(OpCodes.Castclass, paramType);
+                }
+            }
+
+            il.Emit(OpCodes.Newobj, constructor);
+
+            if (constructor.DeclaringType.IsValueType)
+            {
+                il.Emit(OpCodes.Box, constructor.DeclaringType);
+            }
+
+            il.Emit(OpCodes.Ret);
+
+            return (Func<object[], object>)
+                dynamicMethod.CreateDelegate(typeof(Func<object[], object>));
+#endif
+        }
+
+        public static Func<T> GetParameterlessConstructor<T>()
+        {
+            Type type = typeof(T);
+            ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes);
+            if (constructor == null)
+            {
+                throw new ArgumentException(
+                    $"Type {type.Name} does not have a parameterless constructor"
+                );
+            }
+
+#if !EMIT_DYNAMIC_IL
+            return CreateCompiledParameterlessConstructor<T>(constructor);
+#else
+            DynamicMethod dynamicMethod = new(
+                $"CreateParameterless{type.Name}",
+                typeof(T),
+                Type.EmptyTypes,
+                type,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            il.Emit(OpCodes.Newobj, constructor);
+            il.Emit(OpCodes.Ret);
+
+            return (Func<T>)dynamicMethod.CreateDelegate(typeof(Func<T>));
+#endif
+        }
+
+        public static Func<T> GetGenericParameterlessConstructor<T>(
+            Type genericTypeDefinition,
+            params Type[] genericArguments
+        )
+        {
+            Type constructedType = genericTypeDefinition.MakeGenericType(genericArguments);
+            ConstructorInfo constructor = constructedType.GetConstructor(Type.EmptyTypes);
+            if (constructor == null)
+            {
+                throw new ArgumentException(
+                    $"Type {constructedType.Name} does not have a parameterless constructor"
+                );
+            }
+
+#if !EMIT_DYNAMIC_IL
+            return CreateCompiledGenericParameterlessConstructor<T>(constructedType, constructor);
+#else
+            DynamicMethod dynamicMethod = new(
+                $"CreateGenericParameterless{constructedType.Name}",
+                typeof(T),
+                Type.EmptyTypes,
+                constructedType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            il.Emit(OpCodes.Newobj, constructor);
+            if (constructedType.IsValueType && typeof(T) == typeof(object))
+            {
+                il.Emit(OpCodes.Box, constructedType);
+            }
+            il.Emit(OpCodes.Ret);
+
+            return (Func<T>)dynamicMethod.CreateDelegate(typeof(Func<T>));
+#endif
+        }
+
+        public static IEnumerable<Type> GetAllLoadedTypes()
+        {
+            return GetAllLoadedAssemblies()
+                .SelectMany(assembly => GetTypesFromAssembly(assembly))
+                .Where(type => type != null);
+        }
+
+        public static IEnumerable<Assembly> GetAllLoadedAssemblies()
+        {
+            try
+            {
+                return AppDomain
+                    .CurrentDomain.GetAssemblies()
+                    .Where(assembly => assembly != null && !assembly.IsDynamic);
+            }
+            catch
+            {
+                return Enumerable.Empty<Assembly>();
+            }
+        }
+
+        public static Type[] GetTypesFromAssembly(Assembly assembly)
+        {
+            if (assembly == null)
+            {
+                return Type.EmptyTypes;
+            }
+
+            try
+            {
+                return assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException ex)
+            {
+                return ex.Types.Where(t => t != null).ToArray();
+            }
+            catch
+            {
+                return Type.EmptyTypes;
+            }
+        }
+
+        public static Type[] GetTypesFromAssemblyName(string assemblyName)
+        {
+            try
+            {
+                Assembly assembly = Assembly.Load(assemblyName);
+                return GetTypesFromAssembly(assembly);
+            }
+            catch
+            {
+                return Type.EmptyTypes;
+            }
+        }
+
+        public static IEnumerable<Type> GetTypesWithAttribute<TAttribute>()
+            where TAttribute : Attribute
+        {
+            return GetAllLoadedTypes().Where(type => HasAttributeSafe<TAttribute>(type));
+        }
+
+        public static IEnumerable<Type> GetTypesWithAttribute(Type attributeType)
+        {
+            if (attributeType == null || !typeof(Attribute).IsAssignableFrom(attributeType))
+            {
+                return Enumerable.Empty<Type>();
+            }
+
+            return GetAllLoadedTypes().Where(type => HasAttributeSafe(type, attributeType));
+        }
+
+        public static bool HasAttributeSafe<TAttribute>(
+            ICustomAttributeProvider provider,
+            bool inherit = true
+        )
+            where TAttribute : Attribute
+        {
+            if (provider == null)
+            {
+                return false;
+            }
+
+            try
+            {
+                return provider.IsDefined(typeof(TAttribute), inherit);
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public static bool HasAttributeSafe(
+            ICustomAttributeProvider provider,
+            Type attributeType,
+            bool inherit = true
+        )
+        {
+            if (provider == null || attributeType == null)
+            {
+                return false;
+            }
+
+            try
+            {
+                return provider.IsDefined(attributeType, inherit);
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public static TAttribute GetAttributeSafe<TAttribute>(
+            ICustomAttributeProvider provider,
+            bool inherit = true
+        )
+            where TAttribute : Attribute
+        {
+            if (provider == null)
+            {
+                return default;
+            }
+
+            try
+            {
+                if (provider.IsDefined(typeof(TAttribute), inherit))
+                {
+                    object[] attributes = provider.GetCustomAttributes(typeof(TAttribute), inherit);
+                    return attributes.Length > 0 ? attributes[0] as TAttribute : default;
+                }
+            }
+            catch
+            {
+                // Swallow
+            }
+
+            return default;
+        }
+
+        public static Attribute GetAttributeSafe(
+            ICustomAttributeProvider provider,
+            Type attributeType,
+            bool inherit = true
+        )
+        {
+            if (provider == null || attributeType == null)
+            {
+                return null;
+            }
+
+            try
+            {
+                if (provider.IsDefined(attributeType, inherit))
+                {
+                    object[] attributes = provider.GetCustomAttributes(attributeType, inherit);
+                    return attributes.Length > 0 ? attributes[0] as Attribute : null;
+                }
+            }
+            catch
+            {
+                // Swallow
+            }
+
+            return null;
+        }
+
+        public static TAttribute[] GetAllAttributesSafe<TAttribute>(
+            ICustomAttributeProvider provider,
+            bool inherit = true
+        )
+            where TAttribute : Attribute
+        {
+            if (provider == null)
+            {
+                return Array.Empty<TAttribute>();
+            }
+
+            try
+            {
+                if (provider.IsDefined(typeof(TAttribute), inherit))
+                {
+                    return provider
+                        .GetCustomAttributes(typeof(TAttribute), inherit)
+                        .OfType<TAttribute>()
+                        .ToArray();
+                }
+                return Array.Empty<TAttribute>();
+            }
+            catch
+            {
+                return Array.Empty<TAttribute>();
+            }
+        }
+
+        public static Attribute[] GetAllAttributesSafe(
+            ICustomAttributeProvider provider,
+            bool inherit = true
+        )
+        {
+            if (provider == null)
+            {
+                return Array.Empty<Attribute>();
+            }
+
+            try
+            {
+                return provider.GetCustomAttributes(inherit).OfType<Attribute>().ToArray();
+            }
+            catch
+            {
+                return Array.Empty<Attribute>();
+            }
+        }
+
+        public static Attribute[] GetAllAttributesSafe(
+            ICustomAttributeProvider provider,
+            Type attributeType,
+            bool inherit = true
+        )
+        {
+            if (provider == null || attributeType == null)
+            {
+                return Array.Empty<Attribute>();
+            }
+
+            try
+            {
+                if (provider.IsDefined(attributeType, inherit))
+                {
+                    return provider
+                        .GetCustomAttributes(attributeType, inherit)
+                        .OfType<Attribute>()
+                        .ToArray();
+                }
+                return Array.Empty<Attribute>();
+            }
+            catch
+            {
+                return Array.Empty<Attribute>();
+            }
+        }
+
+        public static Dictionary<string, object> GetAllAttributeValuesSafe(
+            ICustomAttributeProvider provider,
+            bool inherit = true
+        )
+        {
+            Dictionary<string, object> result = new();
+
+            foreach (Attribute attr in GetAllAttributesSafe(provider, inherit))
+            {
+                try
+                {
+                    Type attrType = attr.GetType();
+                    string key = attrType.Name;
+
+                    if (key.EndsWith("Attribute"))
+                    {
+                        key = key.Substring(0, key.Length - 9);
+                    }
+
+                    result.TryAdd(key, attr);
+                }
+                catch
+                {
+                    // Skip this attribute if we can't process it
+                }
+            }
+
+            return result;
+        }
+
+        public static MethodInfo[] GetMethodsWithAttributeSafe<TAttribute>(
+            Type type,
+            bool inherit = true
+        )
+            where TAttribute : Attribute
+        {
+            if (type == null)
+            {
+                return Array.Empty<MethodInfo>();
+            }
+
+            try
+            {
+                bool localInherit = inherit;
+                return type.GetMethods(
+                        BindingFlags.Public
+                            | BindingFlags.NonPublic
+                            | BindingFlags.Instance
+                            | BindingFlags.Static
+                    )
+                    .Where(method => HasAttributeSafe<TAttribute>(method, localInherit))
+                    .ToArray();
+            }
+            catch
+            {
+                return Array.Empty<MethodInfo>();
+            }
+        }
+
+        public static PropertyInfo[] GetPropertiesWithAttributeSafe<TAttribute>(
+            Type type,
+            bool inherit = true
+        )
+            where TAttribute : Attribute
+        {
+            if (type == null)
+            {
+                return Array.Empty<PropertyInfo>();
+            }
+
+            try
+            {
+                bool localInherit = inherit;
+                return type.GetProperties(
+                        BindingFlags.Public
+                            | BindingFlags.NonPublic
+                            | BindingFlags.Instance
+                            | BindingFlags.Static
+                    )
+                    .Where(property => HasAttributeSafe<TAttribute>(property, localInherit))
+                    .ToArray();
+            }
+            catch
+            {
+                return Array.Empty<PropertyInfo>();
+            }
+        }
+
+        public static FieldInfo[] GetFieldsWithAttributeSafe<TAttribute>(
+            Type type,
+            bool inherit = true
+        )
+            where TAttribute : Attribute
+        {
+            if (type == null)
+            {
+                return Array.Empty<FieldInfo>();
+            }
+
+            try
+            {
+                bool localInherit = inherit;
+                return type.GetFields(
+                        BindingFlags.Public
+                            | BindingFlags.NonPublic
+                            | BindingFlags.Instance
+                            | BindingFlags.Static
+                    )
+                    .Where(field => HasAttributeSafe<TAttribute>(field, localInherit))
+                    .ToArray();
+            }
+            catch
+            {
+                return Array.Empty<FieldInfo>();
+            }
+        }
+
+        private static bool CheckExpressionCompilationSupport()
+        {
+#if !SUPPORT_EXPRESSION_COMPILE
+            return false;
+#else
+            try
+            {
+                // Test if expression compilation works by trying a simple lambda
+                Expression<Func<int>> testExpr = () => 42;
+                Func<int> compiled = testExpr.Compile();
+                return compiled() == 42;
+            }
+            catch
+            {
+                return false;
+            }
+#endif
+        }
+
+        private static Func<object, object[], object> CreateCompiledMethodInvoker(MethodInfo method)
+        {
+            if (!CanCompileExpressions)
+            {
+                return CreateDelegateMethodInvoker(method)
+                    ?? ((instance, args) => method.Invoke(instance, args));
+            }
+
+            try
+            {
+                ParameterExpression instanceParam = Expression.Parameter(
+                    typeof(object),
+                    "instance"
+                );
+                ParameterExpression argsParam = Expression.Parameter(typeof(object[]), "args");
+
+                Expression instanceExpression = method.DeclaringType.IsValueType
+                    ? Expression.Unbox(instanceParam, method.DeclaringType)
+                    : Expression.Convert(instanceParam, method.DeclaringType);
+
+                ParameterInfo[] parameters = method.GetParameters();
+                Expression[] paramExpressions = new Expression[parameters.Length];
+
+                for (int i = 0; i < parameters.Length; i++)
+                {
+                    Expression argExpression = Expression.ArrayIndex(
+                        argsParam,
+                        Expression.Constant(i)
+                    );
+                    Type paramType = parameters[i].ParameterType;
+                    paramExpressions[i] = paramType.IsValueType
+                        ? Expression.Unbox(argExpression, paramType)
+                        : Expression.Convert(argExpression, paramType);
+                }
+
+                Expression callExpression = Expression.Call(
+                    instanceExpression,
+                    method,
+                    paramExpressions
+                );
+
+                Expression returnExpression =
+                    method.ReturnType == typeof(void)
+                        ? Expression.Block(callExpression, Expression.Constant(null))
+                    : method.ReturnType.IsValueType
+                        ? Expression.Convert(callExpression, typeof(object))
+                    : callExpression;
+
+                return Expression
+                    .Lambda<Func<object, object[], object>>(
+                        returnExpression,
+                        instanceParam,
+                        argsParam
+                    )
+                    .Compile();
+            }
+            catch
+            {
+                return (instance, args) => method.Invoke(instance, args);
+            }
+        }
+
+        private static Func<object[], object> CreateCompiledStaticMethodInvoker(MethodInfo method)
+        {
+            if (!CanCompileExpressions)
+            {
+                return CreateDelegateStaticMethodInvoker(method)
+                    ?? (args => method.Invoke(null, args));
+            }
+
+            try
+            {
+                ParameterExpression argsParam = Expression.Parameter(typeof(object[]), "args");
+
+                ParameterInfo[] parameters = method.GetParameters();
+                Expression[] paramExpressions = new Expression[parameters.Length];
+
+                for (int i = 0; i < parameters.Length; i++)
+                {
+                    Expression argExpression = Expression.ArrayIndex(
+                        argsParam,
+                        Expression.Constant(i)
+                    );
+                    Type paramType = parameters[i].ParameterType;
+                    paramExpressions[i] = paramType.IsValueType
+                        ? Expression.Unbox(argExpression, paramType)
+                        : Expression.Convert(argExpression, paramType);
+                }
+
+                Expression callExpression = Expression.Call(method, paramExpressions);
+
+                Expression returnExpression =
+                    method.ReturnType == typeof(void)
+                        ? Expression.Block(callExpression, Expression.Constant(null))
+                    : method.ReturnType.IsValueType
+                        ? Expression.Convert(callExpression, typeof(object))
+                    : callExpression;
+
+                return Expression
+                    .Lambda<Func<object[], object>>(returnExpression, argsParam)
+                    .Compile();
+            }
+            catch
+            {
+                return args => method.Invoke(null, args);
+            }
+        }
+
+        private static Func<object[], object> CreateCompiledConstructor(ConstructorInfo constructor)
+        {
+            if (!CanCompileExpressions)
+            {
+                return CreateDelegateConstructor(constructor) ?? (args => constructor.Invoke(args));
+            }
+
+            try
+            {
+                ParameterExpression argsParam = Expression.Parameter(typeof(object[]), "args");
+
+                ParameterInfo[] parameters = constructor.GetParameters();
+                Expression[] paramExpressions = new Expression[parameters.Length];
+
+                for (int i = 0; i < parameters.Length; i++)
+                {
+                    Expression argExpression = Expression.ArrayIndex(
+                        argsParam,
+                        Expression.Constant(i)
+                    );
+                    Type paramType = parameters[i].ParameterType;
+                    paramExpressions[i] = paramType.IsValueType
+                        ? Expression.Unbox(argExpression, paramType)
+                        : Expression.Convert(argExpression, paramType);
+                }
+
+                Expression newExpression = Expression.New(constructor, paramExpressions);
+
+                Expression returnExpression = constructor.DeclaringType.IsValueType
+                    ? Expression.Convert(newExpression, typeof(object))
+                    : newExpression;
+
+                return Expression
+                    .Lambda<Func<object[], object>>(returnExpression, argsParam)
+                    .Compile();
+            }
+            catch
+            {
+                return args => constructor.Invoke(args);
+            }
+        }
+
+        private static Func<T> CreateCompiledParameterlessConstructor<T>(
+            ConstructorInfo constructor
+        )
+        {
+            if (!CanCompileExpressions)
+            {
+                return CreateDelegateParameterlessConstructor<T>(constructor)
+                    ?? (() => (T)Activator.CreateInstance(typeof(T)));
+            }
+
+            try
+            {
+                Expression newExpression = Expression.New(constructor);
+                return Expression.Lambda<Func<T>>(newExpression).Compile();
+            }
+            catch
+            {
+                return () => (T)Activator.CreateInstance(typeof(T));
+            }
+        }
+
+        private static Func<T> CreateCompiledGenericParameterlessConstructor<T>(
+            Type constructedType,
+            ConstructorInfo constructor
+        )
+        {
+            if (!CanCompileExpressions)
+            {
+                return () => (T)Activator.CreateInstance(constructedType);
+            }
+
+            try
+            {
+                Expression newExpression = Expression.New(constructor);
+                Expression convertExpression =
+                    constructedType.IsValueType && typeof(T) == typeof(object)
+                        ? Expression.Convert(newExpression, typeof(object))
+                        : newExpression;
+
+                return Expression.Lambda<Func<T>>(convertExpression).Compile();
+            }
+            catch
+            {
+                return () => (T)Activator.CreateInstance(constructedType);
+            }
+        }
+
+        private static Func<object, object> CreateCompiledFieldGetter(FieldInfo field)
+        {
+            if (!CanCompileExpressions)
+            {
+                return CreateDelegateFieldGetter(field) ?? field.GetValue;
+            }
+
+            try
+            {
+                ParameterExpression instanceParam = Expression.Parameter(
+                    typeof(object),
+                    "instance"
+                );
+
+                Expression instanceExpression = field.DeclaringType.IsValueType
+                    ? Expression.Unbox(instanceParam, field.DeclaringType)
+                    : Expression.Convert(instanceParam, field.DeclaringType);
+
+                Expression fieldExpression = Expression.Field(instanceExpression, field);
+
+                Expression returnExpression = field.FieldType.IsValueType
+                    ? Expression.Convert(fieldExpression, typeof(object))
+                    : fieldExpression;
+
+                return Expression
+                    .Lambda<Func<object, object>>(returnExpression, instanceParam)
+                    .Compile();
+            }
+            catch
+            {
+                return field.GetValue;
+            }
+        }
+
+        private static Func<object, object> CreateCompiledPropertyGetter(PropertyInfo property)
+        {
+            if (!CanCompileExpressions)
+            {
+                return CreateDelegatePropertyGetter(property) ?? property.GetValue;
+            }
+
+            try
+            {
+                MethodInfo getMethod = property.GetGetMethod(true);
+                if (getMethod == null)
+                {
+                    return property.GetValue;
+                }
+
+                ParameterExpression instanceParam = Expression.Parameter(
+                    typeof(object),
+                    "instance"
+                );
+
+                Expression instanceExpression = property.DeclaringType.IsValueType
+                    ? Expression.Unbox(instanceParam, property.DeclaringType)
+                    : Expression.Convert(instanceParam, property.DeclaringType);
+
+                Expression propertyExpression = Expression.Property(instanceExpression, property);
+
+                Expression returnExpression = property.PropertyType.IsValueType
+                    ? Expression.Convert(propertyExpression, typeof(object))
+                    : propertyExpression;
+
+                return Expression
+                    .Lambda<Func<object, object>>(returnExpression, instanceParam)
+                    .Compile();
+            }
+            catch
+            {
+                return property.GetValue;
+            }
+        }
+
+        private static Func<object> CreateCompiledStaticFieldGetter(FieldInfo field)
+        {
+            if (!CanCompileExpressions)
+            {
+                return () => field.GetValue(null);
+            }
+
+            try
+            {
+                Expression fieldExpression = Expression.Field(null, field);
+
+                Expression returnExpression = field.FieldType.IsValueType
+                    ? Expression.Convert(fieldExpression, typeof(object))
+                    : fieldExpression;
+
+                return Expression.Lambda<Func<object>>(returnExpression).Compile();
+            }
+            catch
+            {
+                return () => field.GetValue(null);
+            }
+        }
+
+        private static Action<object, object> CreateCompiledFieldSetter(FieldInfo field)
+        {
+            if (!CanCompileExpressions)
+            {
+                return field.SetValue;
+            }
+
+            try
+            {
+                ParameterExpression instanceParam = Expression.Parameter(
+                    typeof(object),
+                    "instance"
+                );
+                ParameterExpression valueParam = Expression.Parameter(typeof(object), "value");
+
+                Expression instanceExpression = field.DeclaringType.IsValueType
+                    ? Expression.Unbox(instanceParam, field.DeclaringType)
+                    : Expression.Convert(instanceParam, field.DeclaringType);
+
+                Expression valueExpression = field.FieldType.IsValueType
+                    ? Expression.Unbox(valueParam, field.FieldType)
+                    : Expression.Convert(valueParam, field.FieldType);
+
+                Expression assignExpression = Expression.Assign(
+                    Expression.Field(instanceExpression, field),
+                    valueExpression
+                );
+
+                return Expression
+                    .Lambda<Action<object, object>>(assignExpression, instanceParam, valueParam)
+                    .Compile();
+            }
+            catch
+            {
+                return field.SetValue;
+            }
+        }
+
+        private static Action<object> CreateCompiledStaticFieldSetter(FieldInfo field)
+        {
+            if (!CanCompileExpressions)
+            {
+                return value => field.SetValue(null, value);
+            }
+
+            try
+            {
+                ParameterExpression valueParam = Expression.Parameter(typeof(object), "value");
+
+                Expression valueExpression = field.FieldType.IsValueType
+                    ? Expression.Unbox(valueParam, field.FieldType)
+                    : Expression.Convert(valueParam, field.FieldType);
+
+                Expression assignExpression = Expression.Assign(
+                    Expression.Field(null, field),
+                    valueExpression
+                );
+
+                return Expression.Lambda<Action<object>>(assignExpression, valueParam).Compile();
+            }
+            catch
+            {
+                return value => field.SetValue(null, value);
+            }
+        }
+
+        private static Func<object, object[], object> CreateDelegateMethodInvoker(MethodInfo method)
+        {
+            try
+            {
+                // For IL2CPP/WebGL, focus on simple optimizations that avoid DynamicInvoke
+                // which can be slower than direct reflection in some cases
+
+                ParameterInfo[] parameters = method.GetParameters();
+
+                // Only optimize very simple cases to avoid DynamicInvoke overhead
+                if (parameters.Length == 0 && method.IsStatic)
+                {
+                    if (method.ReturnType == typeof(void))
+                    {
+                        Action staticAction = (Action)
+                            Delegate.CreateDelegate(typeof(Action), method);
+                        return (instance, args) =>
+                        {
+                            staticAction();
+                            return null;
+                        };
+                    }
+
+                    if (method.ReturnType == typeof(int))
+                    {
+                        Func<int> staticFunc =
+                            (Func<int>)Delegate.CreateDelegate(typeof(Func<int>), method);
+                        return (instance, args) => staticFunc();
+                    }
+
+                    if (method.ReturnType == typeof(string))
+                    {
+                        Func<string> staticFunc =
+                            (Func<string>)Delegate.CreateDelegate(typeof(Func<string>), method);
+                        return (instance, args) => staticFunc();
+                    }
+
+                    if (method.ReturnType == typeof(bool))
+                    {
+                        Func<bool> staticFunc =
+                            (Func<bool>)Delegate.CreateDelegate(typeof(Func<bool>), method);
+                        return (instance, args) => staticFunc();
+                    }
+                }
+
+                // For most other cases, direct reflection is often faster than DynamicInvoke
+                return null;
+            }
+            catch
+            {
+                return null; // Fallback to reflection
+            }
+        }
+
+        private static Func<object[], object> CreateDelegateStaticMethodInvoker(MethodInfo method)
+        {
+            try
+            {
+                ParameterInfo[] parameters = method.GetParameters();
+
+                // Only optimize simple static methods with no parameters to avoid DynamicInvoke
+                if (parameters.Length == 0)
+                {
+                    if (method.ReturnType == typeof(void))
+                    {
+                        Action action = (Action)Delegate.CreateDelegate(typeof(Action), method);
+                        return args =>
+                        {
+                            action();
+                            return null;
+                        };
+                    }
+
+                    if (method.ReturnType == typeof(int))
+                    {
+                        Func<int> func =
+                            (Func<int>)Delegate.CreateDelegate(typeof(Func<int>), method);
+                        return args => func();
+                    }
+
+                    if (method.ReturnType == typeof(string))
+                    {
+                        Func<string> func =
+                            (Func<string>)Delegate.CreateDelegate(typeof(Func<string>), method);
+                        return args => func();
+                    }
+
+                    if (method.ReturnType == typeof(bool))
+                    {
+                        Func<bool> func =
+                            (Func<bool>)Delegate.CreateDelegate(typeof(Func<bool>), method);
+                        return args => func();
+                    }
+                }
+
+                // For other cases, reflection is often faster than DynamicInvoke
+                return null;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static Func<object[], object> CreateDelegateConstructor(ConstructorInfo constructor)
+        {
+            try
+            {
+                ParameterInfo[] parameters = constructor.GetParameters();
+                Type declaringType = constructor.DeclaringType;
+
+                // For constructors, we can use Activator.CreateInstance with optimizations
+                // or create wrapper delegates that call the constructor
+
+                if (parameters.Length == 0)
+                {
+                    // Use cached Activator.CreateInstance for parameterless constructors
+                    return args => Activator.CreateInstance(declaringType);
+                }
+
+                if (parameters.Length == 1)
+                {
+                    Type paramType = parameters[0].ParameterType;
+                    return args => Activator.CreateInstance(declaringType, args[0]);
+                }
+
+                if (parameters.Length == 2)
+                {
+                    return args => Activator.CreateInstance(declaringType, args[0], args[1]);
+                }
+
+                if (parameters.Length <= 4)
+                {
+                    // For up to 4 parameters, use Activator.CreateInstance which is reasonably fast
+                    return args => Activator.CreateInstance(declaringType, args);
+                }
+
+                // For more complex constructors, fallback to reflection
+                return null;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static Func<T> CreateDelegateParameterlessConstructor<T>(
+            ConstructorInfo constructor
+        )
+        {
+            try
+            {
+                // For parameterless constructors, we can use optimized Activator.CreateInstance
+                if (constructor.GetParameters().Length == 0)
+                {
+                    return () => (T)Activator.CreateInstance(typeof(T));
+                }
+
+                return null;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static Func<object, object> CreateDelegateFieldGetter(FieldInfo field)
+        {
+            try
+            {
+                if (field.IsStatic)
+                {
+                    // For static fields, create a simple wrapper
+                    return instance => field.GetValue(null);
+                }
+
+                // For instance fields, we can't easily create delegates, so use optimized wrapper
+                return instance => field.GetValue(instance);
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static Func<object, object> CreateDelegatePropertyGetter(PropertyInfo property)
+        {
+            try
+            {
+                MethodInfo getMethod = property.GetGetMethod(true);
+                if (getMethod == null)
+                {
+                    return null;
+                }
+
+                if (getMethod.IsStatic)
+                {
+                    Type funcType = typeof(Func<>).MakeGenericType(property.PropertyType);
+                    Delegate getter = Delegate.CreateDelegate(funcType, getMethod);
+                    return instance => getter.DynamicInvoke();
+                }
+                else
+                {
+                    Type funcType = typeof(Func<,>).MakeGenericType(
+                        property.DeclaringType,
+                        property.PropertyType
+                    );
+                    Delegate getter = Delegate.CreateDelegate(funcType, getMethod);
+                    return instance => getter.DynamicInvoke(instance);
+                }
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static Func<object, object> CreateGenericFieldGetter(FieldInfo field)
+        {
+            try
+            {
+                // For now, just use direct field access - it's already reasonably fast
+                if (field.IsStatic)
+                {
+                    return instance => field.GetValue(null);
+                }
+
+                return instance => field.GetValue(instance);
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        private static Type GetActionType(Type[] parameterTypes)
+        {
+            switch (parameterTypes.Length)
+            {
+                case 0:
+                    return typeof(Action);
+                case 1:
+                    return typeof(Action<>).MakeGenericType(parameterTypes);
+                case 2:
+                    return typeof(Action<,>).MakeGenericType(parameterTypes);
+                case 3:
+                    return typeof(Action<,,>).MakeGenericType(parameterTypes);
+                case 4:
+                    return typeof(Action<,,,>).MakeGenericType(parameterTypes);
+                default:
+                    return null;
+            }
+        }
+
+        private static Type GetFuncType(Type[] typeArgs)
+        {
+            switch (typeArgs.Length)
+            {
+                case 1:
+                    return typeof(Func<>).MakeGenericType(typeArgs);
+                case 2:
+                    return typeof(Func<,>).MakeGenericType(typeArgs);
+                case 3:
+                    return typeof(Func<,,>).MakeGenericType(typeArgs);
+                case 4:
+                    return typeof(Func<,,,>).MakeGenericType(typeArgs);
+                case 5:
+                    return typeof(Func<,,,,>).MakeGenericType(typeArgs);
+                default:
+                    return null;
+            }
+        }
     }
 }