Merge pull request #3 from tanitaka-tech/perf/module

improve performance(17.54%)

Author: tanitaka-tech

package.json

@@ -1,7 +1,7 @@
 {
     "name": "com.tanitaka-tech.nested-di-container",
     "displayName": "Nested DI Container",
-    "version": "0.0.0",
+    "version": "0.1.0",
     "unity": "2022.3",
     "author": "tanitaka-tech",
     "description": "",

src/NestedDIContainer/Runtime/DependencyBinder.cs

@@ -1,25 +1,20 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 
 namespace TanitakaTech.NestedDIContainer
 {
     public readonly ref struct DependencyBinder
     {
-        private readonly ScopeId _scopeId;
-        private readonly Dictionary<ScopeId, IScope> _scopes;
-        private readonly Modules _modules;
+        private readonly ScopeContainer _scopeContainer;
 
-        public DependencyBinder(ScopeId scopeId, Dictionary<ScopeId, IScope> scopes, Modules modules)
+        public DependencyBinder(ScopeContainer scopeContainer)
         {
-            _scopeId = scopeId;
-            _scopes = scopes;
-            _modules = modules;
+            _scopeContainer = scopeContainer;
         }
 
         public void ExtendScope(IExtendScope scope)
         {
-            GlobalProjectScope.Inject(scope, GlobalProjectScope.Scopes[_scopeId]);
+            _scopeContainer.Inject(scope);
             scope.Construct(this);
         }
 
@@ -29,10 +24,9 @@ public T ExtendScope<T>() where T : IExtendScope
             var constructor = type.GetConstructors().First();
             var parameters = constructor.GetParameters();
             var parameterValues = new object[parameters.Length];
-            _scopes.TryGetValue(_scopeId, out var scope);
             for (int i = 0; i < parameters.Length; i++)
             {
-                parameterValues[i] = _modules.Resolve(parameters[i].ParameterType, scope);
+                parameterValues[i] = _scopeContainer.Resolve(parameters[i].ParameterType);
             }
             var instance = (T)Activator.CreateInstance(type, parameterValues);
 
@@ -49,7 +43,7 @@ public TResult ExtendScopeWithResult<T, TResult>() where T : IExtendScopeWithRes
 
         public void Bind(Type type, object instance)
         {
-            GlobalProjectScope.Modules.Bind(_scopeId, type, instance);
+            _scopeContainer.Bind(type, instance);
         }
 
         public void Bind<T>(T instance) => Bind(typeof(T), instance);

src/NestedDIContainer/Runtime/GlobalProjectScope.cs

@@ -3,7 +3,8 @@
     public interface IScope : IInjectable
     {
         void Construct(DependencyBinder binder, object config);
-        ScopeId ScopeId { get; set; }
-        ScopeId? ParentScopeId { get; set; }
+        ScopeId ScopeId { get; }
+        ScopeId? ParentScopeId { get; }
+        ScopeContainer ScopeContainer { get; }
     }
 }

src/NestedDIContainer/Runtime/GlobalProjectScope.cs.meta

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using NestedDIContainer.Unity.Runtime;
+
+namespace TanitakaTech.NestedDIContainer
+{
+    public class ScopeContainer
+    {
+        private readonly Dictionary<IntPtr, object> _value = new Dictionary<IntPtr, object>();
+        private readonly IScope _scope;
+        private readonly ScopeContainer _parentScopeContainer;
+        public IScope Scope => _scope;
+        public IScope ParentScope => _parentScopeContainer?.Scope;
+
+        public ScopeContainer(IScope scope, ScopeContainer parentScopeContainer)
+        {
+            _scope = scope;
+            _parentScopeContainer = parentScopeContainer;
+        }
+
+        public void Bind(Type type, object module)
+        {
+            var key = type.TypeHandle.Value;
+            if (!_value.TryAdd(key, module))
+            {
+                throw new ConstructException($"Module already exists: {type}, {_scope}");
+            }
+        }
+        
+        public void Remove(Type type)
+        {
+            var key = type.TypeHandle.Value;
+            (_value[key] as IDisposable)?.Dispose();
+            _value.Remove(key);
+        }
+
+        public void RemoveScope()
+        {
+            _value.Clear();
+        }
+
+        public T Resolve<T>()
+        {
+            return (T)Resolve(typeof(T));
+        }
+
+        public object Resolve(Type type)
+        {
+            var typePtr = type.TypeHandle.Value;
+            if (_value.TryGetValue(typePtr, out var module))
+                return module;
+
+            if (_parentScopeContainer != null)
+            {
+                return _parentScopeContainer.Resolve(type);
+            }
+            throw new ConstructException($"Module not found: {type}");
+        }
+
+        private const BindingFlags MemberBindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+        public void Inject(object injectableObject)
+        {
+            var type = injectableObject.GetType();
+            var fields = type.GetFields(MemberBindingFlags);
+            foreach (var field in fields)
+            {
+                var injectAttr = field.GetCustomAttribute<InjectAttribute>();
+                if (injectAttr != null)
+                {
+                    field.SetValue(injectableObject, Resolve(field.FieldType));
+                }
+            }
+
+            var props = type.GetProperties(MemberBindingFlags);
+            foreach (var prop in props)
+            {
+                var injectAttr = prop.GetCustomAttribute<InjectAttribute>();
+                if (injectAttr != null)
+                {
+                    prop.SetValue(Scope, Resolve(prop.PropertyType));
+                }
+            }
+        }
+    }
+}