Merge pull request #40 from mewlist/property-injection

Property Injection
mewlist · Feb 21, 2024 · 7b6bb09 · 7b6bb09
2 parents 0d93491 + fb562d5
commit 7b6bb09
Show file tree

Hide file tree

Showing 14 changed files with 167 additions and 7 deletions.
diff --git a/Runtime/Attribute/InjectAttribute.cs b/Runtime/Attribute/InjectAttribute.cs
@@ -2,7 +2,7 @@
 
 namespace Doinject
 {
-    [AttributeUsage(AttributeTargets.Constructor|AttributeTargets.Method)]
+    [AttributeUsage(AttributeTargets.Constructor|AttributeTargets.Method|AttributeTargets.Field|AttributeTargets.Property)]
     public class InjectAttribute : Attribute
     {
     }

diff --git a/Runtime/DIContainer.cs b/Runtime/DIContainer.cs
@@ -20,6 +20,7 @@ namespace Doinject
     public class DIContainer : IReadOnlyDIContainer, IAsyncDisposable
     {
         private static Dictionary<Type, TargetMethodsInfo> MethodInfoMap { get; } = new();
+        private static Dictionary<Type, TargetPropertiesInfo> PropertyInfoMap { get; } = new();
 
         private IReadOnlyDIContainer Parent { get; set; }
         private Scene Scene { get; set; }
@@ -33,6 +34,7 @@ public class DIContainer : IReadOnlyDIContainer, IAsyncDisposable
         internal ParameterBuilder ParameterBuilder { get; }
         private ConstructorInjector ConstructorInjector { get; }
         private MethodInjector MethodInjector { get; }
+        private PropertyInjector PropertyInjector { get; }
 
         public IReadOnlyDictionary<TargetTypeInfo, IInternalResolver> ReadOnlyBindings => Resolvers;
         internal IReadOnlyDictionary<TargetTypeInfo, ConcurrentObjectBag> ReadOnlyInstanceMap => ResolvedInstanceBag.ReadOnlyInstanceMap;
@@ -48,6 +50,7 @@ public DIContainer(IReadOnlyDIContainer parent = null, Scene scene = default)
             ParameterBuilder = new ParameterBuilder(this);
             ConstructorInjector = new ConstructorInjector(this);
             MethodInjector = new MethodInjector(this);
+            PropertyInjector = new PropertyInjector(this);
             BindFromInstance<IReadOnlyDIContainer, DIContainer>(this);
         }
 
@@ -181,10 +184,12 @@ private async ValueTask<object> InstantiateInternalAsync(Type targetType, object
 
             var target = await ConstructorInjector.DoInject(targetType, args, scopedInstances);
             var targetMethodsInfo = GetTargetMethodInfo(targetType);
+            var targetPropertiesInfo = GetTargetPropertyInfo(targetType);
 
             try
             {
                 await MethodInjector.DoInject(target, targetMethodsInfo, args, scopedInstances);
+                await PropertyInjector.DoInject(target, targetPropertiesInfo);
             }
             catch (Exception e)
             {
@@ -266,10 +271,12 @@ private async ValueTask InjectIntoInternalAsync<T>(T target, object[] args, Scop
 
             var targetType = target.GetType();
             var targetMethodsInfo = GetTargetMethodInfo(targetType);
+            var targetPropertiesInfo = GetTargetPropertyInfo(targetType);
 
             try
             {
                 await MethodInjector.DoInject(target, targetMethodsInfo, args, scopedInstances);
+                await PropertyInjector.DoInject(target, targetPropertiesInfo);
             }
             catch (Exception e)
             {
@@ -397,6 +404,16 @@ private TargetMethodsInfo GetTargetMethodInfo(Type targetType)
             return targetMethodsInfo;
         }
 
+        private TargetPropertiesInfo GetTargetPropertyInfo(Type targetType)
+        {
+            if (PropertyInfoMap.TryGetValue(targetType, out var targetPropertiesInfo))
+                return targetPropertiesInfo;
+
+            targetPropertiesInfo = new TargetPropertiesInfo(targetType);
+            PropertyInfoMap[targetType] = targetPropertiesInfo;
+            return targetPropertiesInfo;
+        }
+
         public async ValueTask DisposeAsync()
         {
             if (CancellationTokenSource.IsCancellationRequested) return;

diff --git a/Runtime/Injector/MethodInjector.cs b/Runtime/Injector/MethodInjector.cs
@@ -1,7 +1,4 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 #if USE_UNITASK
 using Cysharp.Threading.Tasks;
 #endif

diff --git a/Runtime/Injector/PropertyInjector.cs b/Runtime/Injector/PropertyInjector.cs
@@ -0,0 +1,36 @@
+using System.Threading.Tasks;
+
+namespace Doinject
+{
+    internal class PropertyInjector
+    {
+        private DIContainer Container { get; }
+        private ParameterBuilder ParameterBuilder { get; }
+
+        public PropertyInjector(DIContainer container)
+        {
+            Container = container;
+            ParameterBuilder = container.ParameterBuilder;
+        }
+
+        public async ValueTask DoInject<T>(
+            T target,
+            TargetPropertiesInfo properties)
+        {
+            if (!properties.Any()) return;
+            var targetType = target.GetType();
+            var resolverType = targetType;
+
+            if (targetType == typeof(IInjectableComponent))
+                resolverType = target.GetType();
+
+            Container.MarkInjected(resolverType);
+
+            foreach (var propertyInfo in properties.InjectProperties)
+            {
+                var instance = await Container.ResolveAsync(propertyInfo.PropertyType);
+                propertyInfo.SetValue(target, instance);
+            }
+        }
+    }
+}
diff --git a/Runtime/Injector/PropertyInjector.cs.meta b/Runtime/Injector/PropertyInjector.cs.meta
diff --git a/Runtime/TargetMethodsInfo.cs b/Runtime/TargetMethodsInfo.cs
@@ -12,20 +12,28 @@ internal class TargetMethodsInfo
 
         public TargetMethodsInfo(Type targetType)
         {
-            foreach (var methodInfo in targetType.GetMethods())
+            foreach (var methodInfo in targetType.GetMethods(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic))
             {
                 if (methodInfo.GetCustomAttributes(typeof(InjectAttribute), true).Length > 0)
+                {
+                    if (!methodInfo.IsPublic)
+                        throw new Exception($"Inject method must be public. {targetType.Name}.{methodInfo.Name}()");
                     InjectMethods.Add(methodInfo);
+                }
 
                 if (methodInfo.GetCustomAttributes(typeof(PostInjectAttribute), true).Length > 0)
                 {
+                    if (!methodInfo.IsPublic)
+                        throw new Exception($"PostInject method must be public. {targetType.Name}.{methodInfo.Name}()");
                     if (methodInfo.GetParameters().Length > 0)
                         throw new Exception("PostInject method should not have any parameters");
                     PostInjectMethods.Add(methodInfo);
                 }
 
                 if (methodInfo.GetCustomAttributes(typeof(OnInjectedAttribute), true).Length > 0)
                 {
+                    if (!methodInfo.IsPublic)
+                        throw new Exception($"OnInjected method must be public. {targetType.Name}.{methodInfo.Name}()");
                     if (methodInfo.GetParameters().Length > 0)
                         throw new Exception("OnInjected method should not have any parameters");
                     OnInjectedMethods.Add(methodInfo);

diff --git a/Runtime/TargetPropertiesInfo.cs b/Runtime/TargetPropertiesInfo.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace Doinject
+{
+    internal class TargetPropertiesInfo
+    {
+        public List<PropertyInfo> InjectProperties { get; } = new();
+
+        public TargetPropertiesInfo(Type targetType)
+        {
+            foreach (var propertyInfo in targetType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
+            {
+                if (propertyInfo.GetCustomAttributes(typeof(InjectAttribute), true).Length <= 0)
+                    continue;
+
+                if (!propertyInfo.CanWrite || !propertyInfo.SetMethod.IsPublic)
+                    throw new Exception($"Property must have a public setter. {targetType.Name}.{propertyInfo.Name}");
+
+                InjectProperties.Add(propertyInfo);
+            }
+        }
+
+        public bool Any()
+            => InjectProperties.Count > 0;
+    }
+}
diff --git a/Runtime/TargetPropertiesInfo.cs.meta b/Runtime/TargetPropertiesInfo.cs.meta
diff --git a/Tests/Components/PropertyInjectionComponent.cs b/Tests/Components/PropertyInjectionComponent.cs
@@ -0,0 +1,10 @@
+using UnityEngine;
+
+namespace Doinject.Tests
+{
+    public class PropertyInjectionComponent : MonoBehaviour, IInjectableComponent
+    {
+        [Inject]
+        public InjectedObject InjectedObject { get; set; }
+    }
+}
diff --git a/Tests/Components/PropertyInjectionComponent.cs.meta b/Tests/Components/PropertyInjectionComponent.cs.meta
diff --git a/Tests/Components/PropertyInjectionWithNonPublicSetterComponent.cs b/Tests/Components/PropertyInjectionWithNonPublicSetterComponent.cs
@@ -0,0 +1,10 @@
+using UnityEngine;
+
+namespace Doinject.Tests
+{
+    public class PropertyInjectionWithNonPublicSetterComponent : MonoBehaviour, IInjectableComponent
+    {
+        [Inject]
+        public InjectedObject InjectedObject { get; private set; }
+    }
+}
diff --git a/Tests/Components/PropertyInjectionWithNonPublicSetterComponent.cs.meta b/Tests/Components/PropertyInjectionWithNonPublicSetterComponent.cs.meta
diff --git a/Tests/InjectionTest.cs b/Tests/InjectionTest.cs
@@ -2,6 +2,7 @@
 using System.Threading.Tasks;
 using Mew.Core.TaskHelpers;
 using NUnit.Framework;
+using UnityEngine.SceneManagement;
 
 namespace Doinject.Tests
 {
@@ -12,7 +13,8 @@ public class InjectionTest
         [SetUp]
         public void Setup()
         {
-            container = new DIContainer();
+            var scene = SceneManager.GetActiveScene();
+            container = new DIContainer(parent: null, scene);
         }
 
         [TearDown]
@@ -124,5 +126,40 @@ public async Task InjectedCallbackTest()
             await TaskHelperInternal.NextFrame();
             Assert.That(instance.OnInjectedCalled, Is.True);
         }
+
+        [Test]
+        public async Task PropertyInjectionTest()
+        {
+            container.BindTransient<PropertyInjectionObject>();
+            container.BindTransient<InjectedObject>();
+            var instance = await container.ResolveAsync<PropertyInjectionObject>();
+            Assert.NotNull(instance.InjectedObject);
+        }
+
+        [Test]
+        public async Task PropertyInjectionComponentTest()
+        {
+            container.BindTransient<PropertyInjectionComponent>();
+            container.BindTransient<InjectedObject>();
+            var instance = await container.ResolveAsync<PropertyInjectionComponent>();
+            Assert.NotNull(instance.InjectedObject);
+        }
+
+        [Test]
+        public async Task PropertyInjectionWithNonPublicSetterComponentTest()
+        {
+            container.BindTransient<PropertyInjectionWithNonPublicSetterComponent>();
+            container.BindTransient<InjectedObject>();
+            try
+            {
+                await container.ResolveAsync<PropertyInjectionWithNonPublicSetterComponent>();
+            }
+            catch (Exception e)
+            {
+                Assert.Pass();
+
+            }
+            Assert.Fail();
+        }
     }
 }
diff --git a/Tests/TestObjects.cs b/Tests/TestObjects.cs
@@ -89,6 +89,11 @@ public OptionalInjectionTestClass([Optional]InjectedObject injectedObject)
         }
     }
 
+    public class PropertyInjectionObject
+    {
+        [Inject] public InjectedObject InjectedObject { get; set; }
+    }
+
     public class InjectableObject : IDisposable
     {
         public InjectedObject InjectedObject { get; set; }