Merge pull request #42 from mewlist/field-injection

Field Injection
mewlist · Feb 21, 2024 · d64cabe · d64cabe
2 parents b148ec7 + dd5143f
commit d64cabe
Show file tree

Hide file tree

Showing 9 changed files with 171 additions and 5 deletions.
diff --git a/Runtime/DIContainer.cs b/Runtime/DIContainer.cs
@@ -21,6 +21,7 @@ public class DIContainer : IReadOnlyDIContainer, IAsyncDisposable
     {
         private static Dictionary<Type, TargetMethodsInfo> MethodInfoMap { get; } = new();
         private static Dictionary<Type, TargetPropertiesInfo> PropertyInfoMap { get; } = new();
+        private static Dictionary<Type, TargetFieldsInfo> FieldInfoMap { get; } = new();
 
         private IReadOnlyDIContainer Parent { get; set; }
         private Scene Scene { get; set; }
@@ -35,6 +36,7 @@ public class DIContainer : IReadOnlyDIContainer, IAsyncDisposable
         private ConstructorInjector ConstructorInjector { get; }
         private MethodInjector MethodInjector { get; }
         private PropertyInjector PropertyInjector { get; }
+        private FieldInjector FieldInjector { get; }
 
         public IReadOnlyDictionary<TargetTypeInfo, IInternalResolver> ReadOnlyBindings => Resolvers;
         internal IReadOnlyDictionary<TargetTypeInfo, ConcurrentObjectBag> ReadOnlyInstanceMap => ResolvedInstanceBag.ReadOnlyInstanceMap;
@@ -51,6 +53,7 @@ public DIContainer(IReadOnlyDIContainer parent = null, Scene scene = default)
             ConstructorInjector = new ConstructorInjector(this);
             MethodInjector = new MethodInjector(this);
             PropertyInjector = new PropertyInjector(this);
+            FieldInjector = new FieldInjector(this);
             BindFromInstance<IReadOnlyDIContainer, DIContainer>(this);
         }
 
@@ -183,13 +186,28 @@ private async ValueTask<object> InstantiateInternalAsync(Type targetType, object
             AfterInjectionProcessingScope.Begin();
 
             var target = await ConstructorInjector.DoInject(targetType, args, scopedInstances);
-            var targetMethodsInfo = GetTargetMethodInfo(targetType);
-            var targetPropertiesInfo = GetTargetPropertyInfo(targetType);
+
+            TargetMethodsInfo targetMethodsInfo;
+            TargetPropertiesInfo targetPropertiesInfo;
+            TargetFieldsInfo targetFieldsInfo;
+            try
+            {
+                targetMethodsInfo = GetTargetMethodInfo(targetType);
+                targetPropertiesInfo = GetTargetPropertyInfo(targetType);
+                targetFieldsInfo = GetTargetFieldInfo(targetType);
+            }
+            catch (Exception e)
+            {
+                InjectionProcessingScope.End();
+                AfterInjectionProcessingScope.End();
+                throw new FailedToInjectException(target, e);
+            }
 
             try
             {
                 await MethodInjector.DoInject(target, targetMethodsInfo, args, scopedInstances);
                 await PropertyInjector.DoInject(target, targetPropertiesInfo);
+                await FieldInjector.DoInject(target, targetFieldsInfo);
             }
             catch (Exception e)
             {
@@ -270,13 +288,27 @@ private async ValueTask InjectIntoInternalAsync<T>(T target, object[] args, Scop
             AfterInjectionProcessingScope.Begin();
 
             var targetType = target.GetType();
-            var targetMethodsInfo = GetTargetMethodInfo(targetType);
-            var targetPropertiesInfo = GetTargetPropertyInfo(targetType);
+            TargetMethodsInfo targetMethodsInfo;
+            TargetPropertiesInfo targetPropertiesInfo;
+            TargetFieldsInfo targetFieldsInfo;
+            try
+            {
+                targetMethodsInfo = GetTargetMethodInfo(targetType);
+                targetPropertiesInfo = GetTargetPropertyInfo(targetType);
+                targetFieldsInfo = GetTargetFieldInfo(targetType);
+            }
+            catch (Exception e)
+            {
+                InjectionProcessingScope.End();
+                AfterInjectionProcessingScope.End();
+                throw new FailedToInjectException(target, e);
+            }
 
             try
             {
                 await MethodInjector.DoInject(target, targetMethodsInfo, args, scopedInstances);
                 await PropertyInjector.DoInject(target, targetPropertiesInfo);
+                await FieldInjector.DoInject(target, targetFieldsInfo);
             }
             catch (Exception e)
             {
@@ -414,6 +446,16 @@ private TargetPropertiesInfo GetTargetPropertyInfo(Type targetType)
             return targetPropertiesInfo;
         }
 
+        private TargetFieldsInfo GetTargetFieldInfo(Type targetType)
+        {
+            if (FieldInfoMap.TryGetValue(targetType, out var targetFieldsInfo))
+                return targetFieldsInfo;
+
+            targetFieldsInfo = new TargetFieldsInfo(targetType);
+            FieldInfoMap[targetType] = targetFieldsInfo;
+            return targetFieldsInfo;
+        }
+
         public async ValueTask DisposeAsync()
         {
             if (CancellationTokenSource.IsCancellationRequested) return;

diff --git a/Runtime/Injector/FieldInjector.cs b/Runtime/Injector/FieldInjector.cs
@@ -0,0 +1,36 @@
+using System.Threading.Tasks;
+
+namespace Doinject
+{
+    internal class FieldInjector
+    {
+        private DIContainer Container { get; }
+        private ParameterBuilder ParameterBuilder { get; }
+
+        public FieldInjector(DIContainer container)
+        {
+            Container = container;
+            ParameterBuilder = container.ParameterBuilder;
+        }
+
+        public async ValueTask DoInject<T>(
+            T target,
+            TargetFieldsInfo fields)
+        {
+            if (!fields.Any()) return;
+            var targetType = target.GetType();
+            var resolverType = targetType;
+
+            if (targetType == typeof(IInjectableComponent))
+                resolverType = target.GetType();
+
+            Container.MarkInjected(resolverType);
+
+            foreach (var fieldInfo in fields.InjectFields)
+            {
+                var instance = await Container.ResolveAsync(fieldInfo.FieldType);
+                fieldInfo.SetValue(target, instance);
+            }
+        }
+    }
+}
diff --git a/Runtime/Injector/FieldInjector.cs.meta b/Runtime/Injector/FieldInjector.cs.meta
diff --git a/Runtime/TargetFieldsInfo.cs b/Runtime/TargetFieldsInfo.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace Doinject
+{
+    internal class TargetFieldsInfo
+    {
+        public List<FieldInfo> InjectFields { get; } = new();
+
+        public TargetFieldsInfo(Type targetType)
+        {
+            foreach (var fieldInfo in targetType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
+            {
+                if (fieldInfo.GetCustomAttributes(typeof(InjectAttribute), true).Length <= 0)
+                    continue;
+
+                if (!fieldInfo.IsPublic)
+                    throw new Exception($"Field must be public. {targetType.Name}.{fieldInfo.Name}");
+                InjectFields.Add(fieldInfo);
+            }
+        }
+
+        public bool Any()
+            => InjectFields.Count > 0;
+    }
+}
diff --git a/Runtime/TargetFieldsInfo.cs.meta b/Runtime/TargetFieldsInfo.cs.meta
diff --git a/Tests/Components/FieldInjectionComponent.cs b/Tests/Components/FieldInjectionComponent.cs
@@ -0,0 +1,9 @@
+using UnityEngine;
+
+namespace Doinject.Tests
+{
+    public class FieldInjectionComponent : MonoBehaviour, IInjectableComponent
+    {
+        [Inject] public InjectedObject injectedObject;
+    }
+}
diff --git a/Tests/Components/FieldInjectionComponent.cs.meta b/Tests/Components/FieldInjectionComponent.cs.meta
diff --git a/Tests/InjectionTest.cs b/Tests/InjectionTest.cs
@@ -154,10 +154,43 @@ public async Task PropertyInjectionWithNonPublicSetterComponentTest()
             {
                 await container.ResolveAsync<PropertyInjectionWithNonPublicSetterComponent>();
             }
-            catch (Exception e)
+            catch (Exception _)
             {
                 Assert.Pass();
+            }
+            Assert.Fail();
+        }
 
+        [Test]
+        public async Task FieldInjectionTest()
+        {
+            container.BindTransient<FieldInjectionObject>();
+            container.BindTransient<InjectedObject>();
+            var instance = await container.ResolveAsync<FieldInjectionObject>();
+            Assert.NotNull(instance.injectedObject);
+        }
+
+        [Test]
+        public async Task FieldInjectionComponentTest()
+        {
+            container.BindTransient<FieldInjectionComponent>();
+            container.BindTransient<InjectedObject>();
+            var instance = await container.ResolveAsync<FieldInjectionComponent>();
+            Assert.NotNull(instance.injectedObject);
+        }
+
+        [Test]
+        public async Task FieldInjectionWithNonPublicSetterComponentTest()
+        {
+            container.BindTransient<FieldInjectionWithNonPublicObject>();
+            container.BindTransient<InjectedObject>();
+            try
+            {
+                await container.ResolveAsync<FieldInjectionWithNonPublicObject>();
+            }
+            catch (Exception _)
+            {
+                Assert.Pass();
             }
             Assert.Fail();
         }

diff --git a/Tests/TestObjects.cs b/Tests/TestObjects.cs
@@ -94,6 +94,16 @@ public class PropertyInjectionObject
         [Inject] public InjectedObject InjectedObject { get; set; }
     }
 
+    public class FieldInjectionObject
+    {
+        [Inject] public InjectedObject injectedObject;
+    }
+
+    public class FieldInjectionWithNonPublicObject
+    {
+        [Inject] private InjectedObject injectedObject;
+    }
+
     public class InjectableObject : IDisposable
     {
         public InjectedObject InjectedObject { get; set; }