com.wallstop-studios.unity-helpers 2.0.0-rc40 → 2.0.0-rc41

package/Runtime/Core/Helper/ReflectionHelpers.cs

@@ -72,6 +72,76 @@
 #endif
         }
 
+        public static Func<TInstance, TValue> GetFieldGetter<TInstance, TValue>(FieldInfo field)
+        {
+#if WEB_GL
+            return Getter;
+            TValue Getter(TInstance instance)
+            {
+                return (TValue)field.GetValue(instance);
+            }
+#else
+            DynamicMethod dynamicMethod = new(
+                $"GetGeneric{field.DeclaringType.Name}{field.Name}",
+                typeof(TValue),
+                new[] { typeof(TInstance) },
+                field.DeclaringType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+
+            if (!field.IsStatic)
+            {
+                if (typeof(TInstance).IsValueType)
+                {
+                    il.Emit(OpCodes.Ldarga_S, 0);
+                }
+                else
+                {
+                    il.Emit(OpCodes.Ldarg_0);
+                }
+
+                if (field.DeclaringType != typeof(TInstance))
+                {
+                    il.Emit(
+                        field.DeclaringType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass,
+                        field.DeclaringType
+                    );
+                }
+
+                il.Emit(OpCodes.Ldfld, field);
+            }
+            else
+            {
+                il.Emit(OpCodes.Ldsfld, field);
+            }
+
+            if (field.FieldType.IsValueType)
+            {
+                if (!typeof(TValue).IsValueType)
+                {
+                    il.Emit(OpCodes.Box, field.FieldType);
+                }
+            }
+            else
+            {
+                if (typeof(TValue).IsValueType)
+                {
+                    il.Emit(OpCodes.Unbox_Any, typeof(TValue));
+                }
+                else if (typeof(TValue) != field.FieldType)
+                {
+                    il.Emit(OpCodes.Castclass, typeof(TValue));
+                }
+            }
+
+            il.Emit(OpCodes.Ret);
+            return (Func<TInstance, TValue>)
+                dynamicMethod.CreateDelegate(typeof(Func<TInstance, TValue>));
+#endif
+        }
+
         public static FieldSetter<TInstance, TValue> GetFieldSetter<TInstance, TValue>(
             FieldInfo field
         )

package/Tests/Runtime/Helper/ReflectionHelperTests.cs

@@ -22,6 +22,7 @@
 
         private readonly Random _random = new();
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldGetterClass()
         {
@@ -37,6 +38,7 @@
             }
         }
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldGetterStruct()
         {
@@ -52,6 +54,7 @@
             }
         }
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldSetterClass()
         {
@@ -67,6 +70,7 @@
             }
         }
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldSetterStruct()
         {
@@ -83,22 +87,24 @@
             }
         }
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldSetterClassGeneric()
         {
             TestClass testClass = new();
-            FieldSetter<TestClass, int> structSetter = ReflectionHelpers.GetFieldSetter<
+            FieldSetter<TestClass, int> classSetter = ReflectionHelpers.GetFieldSetter<
                 TestClass,
                 int
             >(typeof(TestClass).GetField(nameof(TestClass.intValue)));
             for (int i = 0; i < NumTries; ++i)
             {
                 int expected = _random.Next(int.MinValue, int.MaxValue);
-                structSetter(ref testClass, expected);
+                classSetter(ref testClass, expected);
                 Assert.AreEqual(expected, testClass.intValue);
             }
         }
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldSetterStructGeneric()
         {
@@ -115,6 +121,36 @@
             }
         }
 
+        // TODO: Test on static fields
+        [Test]
+        public void GetFieldGetterClassGeneric()
+        {
+            TestClass testClass = new();
+            Func<TestClass, int> classGetter = ReflectionHelpers.GetFieldGetter<TestClass, int>(
+                typeof(TestClass).GetField(nameof(TestClass.intValue))
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                testClass.intValue = _random.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(testClass.intValue, classGetter(testClass));
+            }
+        }
+
+        // TODO: Test on static fields
+        [Test]
+        public void GetFieldGetterStructGeneric()
+        {
+            TestStruct testStruct = new();
+            Func<TestStruct, int> structSetter = ReflectionHelpers.GetFieldGetter<TestStruct, int>(
+                typeof(TestStruct).GetField(nameof(TestStruct.intValue))
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                testStruct.intValue = _random.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(testStruct.intValue, structSetter(testStruct));
+            }
+        }
+
         [Test]
         public void ArrayCreator()
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc40",
+  "version": "2.0.0-rc41",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},