com.kylin.di 1.0.0

package/Runtime/DI/KDI.cs

@@ -0,0 +1,54 @@
+using UnityEngine;
+
+namespace Kylin.DI
+{
+    /// <summary>
+    /// KDI (Kylin Dependency Injection) - Static Facade
+    ///
+    /// 사용 패턴:
+    /// 1. 서비스 등록: LifetimeScope 상속 클래스에서 Configure(ScopeBuilder builder)에서 등록
+    /// 2. 서비스 해결: this.Inject(scope) 또는 scope.Resolve() 사용
+    /// 3. 자동 주입 (권장): [Inject] 어트리뷰트 + DIBehaviour
+    /// </summary>
+    public static class KDI
+    {
+        private static IScope _rootScope;
+
+        /// <summary>
+        /// RootScope 접근점.
+        /// parent가 없는 LifetimeScope가 Initialize()할 때 자동 설정됨.
+        /// </summary>
+        public static IScope RootScope
+        {
+            get
+            {
+                if (_rootScope == null)
+                {
+                    Debug.LogWarning("[KDI] RootScope가 설정되지 않았습니다. 빈 RootScope를 자동 생성합니다.");
+                    _rootScope = new ScopeBuilder().Build(parent: null);
+                }
+                return _rootScope;
+            }
+        }
+
+        /// <summary>
+        /// RootScope 설정. parent가 없는 LifetimeScope에서 호출.
+        /// </summary>
+        internal static void SetRootScope(IScope scope)
+        {
+            if (_rootScope != null)
+            {
+                Debug.LogWarning("[KDI] RootScope가 이미 설정되어 있습니다. 기존 RootScope를 교체합니다.");
+            }
+            _rootScope = scope;
+        }
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        private static void Reset()
+        {
+            _rootScope?.Dispose();
+            _rootScope = null;
+            DependencyInjector.ClearCache();
+        }
+    }
+}

package/Runtime/DI/KDI.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b5eea526850baa745923747c4f1bed17

package/Runtime/DI/Registration.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace Kylin.DI
+{
+    public enum Lifetime
+    {
+        Transient,  // 매번 새 인스턴스 생성
+        Singleton,  // 단일 인스턴스 유지 (RootScope에서만)
+        Scoped      // 해당 Scope 내 단일 인스턴스
+    }
+
+    public interface IDependencyObject { }
+
+    public interface IInjectable { }
+
+    public interface IPostInjectable
+    {
+        void PostInject();
+    }
+
+    public class Registration
+    {
+        public Type ServiceType { get; set; }
+        public Type ImplementationType { get; set; }
+        public object Instance { get; set; }
+        public Lifetime Lifetime { get; set; }
+        public Func<IScope, object> Factory { get; set; }
+    }
+}

package/Runtime/DI/Registration.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 767481a9a1a5db543b78c3f6296cbcb7

package/Runtime/DI/Scope.cs

@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Kylin.DI
+{
+    public interface IScope : IDisposable
+    {
+        IScope Parent { get; }
+        T Resolve<T>() where T : class;
+        object Resolve(Type type);
+    }
+
+    public class Scope : IScope
+    {
+        [ThreadStatic]
+        private static HashSet<Type> _resolvingTypes;
+
+        private readonly Dictionary<Type, Registration> _registrations;
+        private readonly Dictionary<Type, object> _instances = new();
+        private readonly IScope _parent;
+        private readonly List<IScope> _children = new();
+        private readonly object _lock = new();
+        private bool _isDisposed;
+
+        public IScope Parent => _parent;
+
+        internal Scope(Dictionary<Type, Registration> registrations, IScope parent)
+        {
+            _registrations = registrations;
+            _parent = parent;
+
+            if (parent is Scope parentScope)
+            {
+                lock (parentScope._lock)
+                {
+                    parentScope._children.Add(this);
+                }
+            }
+        }
+
+        public T Resolve<T>() where T : class
+        {
+            return (T)Resolve(typeof(T));
+        }
+
+        public object Resolve(Type type)
+        {
+            if (_isDisposed) throw new ObjectDisposedException(nameof(Scope));
+
+            _resolvingTypes ??= new HashSet<Type>();
+
+            if (!_resolvingTypes.Add(type))
+            {
+                var chain = string.Join(" → ", _resolvingTypes);
+                _resolvingTypes.Clear();
+                throw new InvalidOperationException($"[KDI] 순환참조 발생: {chain} → {type.Name}");
+            }
+
+            try
+            {
+                return ResolveInternal(type);
+            }
+            finally
+            {
+                _resolvingTypes.Remove(type);
+            }
+        }
+
+        private object ResolveInternal(Type type)
+        {
+            lock (_lock)
+            {
+                if (_instances.TryGetValue(type, out var cached))
+                    return cached;
+            }
+
+            if (_registrations.TryGetValue(type, out var reg))
+            {
+                if (reg.Instance != null)
+                {
+                    lock (_lock)
+                    {
+                        _instances[type] = reg.Instance;
+                    }
+                    return reg.Instance;
+                }
+
+                var instance = CreateInstance(reg);
+
+                if (reg.Lifetime == Lifetime.Scoped || reg.Lifetime == Lifetime.Singleton)
+                {
+                    lock (_lock)
+                    {
+                        _instances[type] = instance;
+                    }
+                }
+
+                return instance;
+            }
+
+            if (_parent != null)
+                return _parent.Resolve(type);
+
+            throw new InvalidOperationException($"[KDI] {type.Name}에 대한 등록을 찾을 수 없습니다.");
+        }
+
+        private object CreateInstance(Registration registration)
+        {
+            object instance;
+
+            if (registration.Factory != null)
+            {
+                instance = registration.Factory(this);
+            }
+            else
+            {
+                instance = InstanceFactory.Create(registration.ImplementationType);
+            }
+
+            if (instance is IInjectable injectable)
+            {
+                DependencyInjector.Inject(injectable, this);
+            }
+            else
+            {
+                DependencyInjector.WarnIfHasInjectFieldsWithoutIInjectable(instance);
+            }
+
+            if (instance is IUpdatable ||
+                instance is IFixedUpdatable ||
+                instance is ILateUpdatable)
+            {
+                UpdateLoopManager.Instance.Register(instance);
+            }
+
+            return instance;
+        }
+
+        public void Dispose()
+        {
+            if (_isDisposed) return;
+            _isDisposed = true;
+
+            if (_parent is Scope parentScope)
+            {
+                lock (parentScope._lock)
+                {
+                    parentScope._children.Remove(this);
+                }
+            }
+
+            List<IScope> childrenSnapshot;
+            lock (_lock)
+            {
+                childrenSnapshot = new List<IScope>(_children);
+                _children.Clear();
+            }
+
+            foreach (var child in childrenSnapshot)
+            {
+                child.Dispose();
+            }
+
+            foreach (var instance in _instances.Values)
+            {
+                if (instance is IDisposable disposable)
+                {
+                    try { disposable.Dispose(); }
+                    catch { /* ignore */ }
+                }
+
+                if (instance is IUpdatable ||
+                    instance is IFixedUpdatable ||
+                    instance is ILateUpdatable)
+                {
+                    UpdateLoopManager.Instance?.Unregister(instance);
+                }
+            }
+            _instances.Clear();
+        }
+    }
+}

package/Runtime/DI/Scope.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: bb116a8d0de85884185f557d59585f3f

package/Runtime/DI/ScopeBuilder.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+
+namespace Kylin.DI
+{
+    public class ScopeBuilder
+    {
+        private readonly Dictionary<Type, Registration> _registrations = new();
+        private bool _isBuilt;
+
+        public DependencyBuilder<T> Bind<T>() where T : class
+        {
+            if (_isBuilt) throw new InvalidOperationException("[KDI] 이미 빌드된 ScopeBuilder에 등록할 수 없습니다.");
+            return new DependencyBuilder<T>(this, typeof(T));
+        }
+
+        public void RegisterFactory<T>(Func<IScope, T> factory, Lifetime lifetime) where T : class
+        {
+            if (_isBuilt) throw new InvalidOperationException("[KDI] 이미 빌드된 ScopeBuilder에 등록할 수 없습니다.");
+
+            var serviceType = typeof(T);
+            _registrations[serviceType] = new Registration
+            {
+                ServiceType = serviceType,
+                Factory = scope => factory(scope),
+                Lifetime = lifetime
+            };
+        }
+
+        public void RegisterInstance<T>(T instance) where T : class
+        {
+            if (_isBuilt) throw new InvalidOperationException("[KDI] 이미 빌드된 ScopeBuilder에 등록할 수 없습니다.");
+
+            var serviceType = typeof(T);
+            _registrations[serviceType] = new Registration
+            {
+                ServiceType = serviceType,
+                Instance = instance,
+                Lifetime = Lifetime.Scoped
+            };
+        }
+
+        internal void AddRegistration(Registration registration)
+        {
+            if (_isBuilt) throw new InvalidOperationException("[KDI] 이미 빌드된 ScopeBuilder에 등록할 수 없습니다.");
+            _registrations[registration.ServiceType] = registration;
+        }
+
+        public IScope Build(IScope parent = null)
+        {
+            if (_isBuilt) throw new InvalidOperationException("[KDI] ScopeBuilder는 한 번만 Build할 수 있습니다.");
+
+            // child scope에서 Singleton 등록 검증
+            if (parent != null)
+            {
+                foreach (var reg in _registrations.Values)
+                {
+                    if (reg.Lifetime == Lifetime.Singleton)
+                        throw new InvalidOperationException(
+                            $"[KDI] Singleton은 RootScope에서만 등록 가능합니다: {reg.ServiceType.Name}");
+                }
+            }
+
+            _isBuilt = true;
+            return new Scope(_registrations, parent);
+        }
+    }
+}

package/Runtime/DI/ScopeBuilder.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 46fb707d55feb5d48a9d87df0ff76a6a

package/Runtime/DI/ScopeExtensions.cs

@@ -0,0 +1,70 @@
+using UnityEngine;
+
+namespace Kylin.DI
+{
+    /// <summary>
+    /// IScope 확장 메서드.
+    /// 동적 생성 시 DI 주입을 지원한다.
+    /// </summary>
+    public static class ScopeExtensions
+    {
+        /// <summary>
+        /// GameObject의 하위 IInjectable MonoBehaviour에 주입.
+        /// 동적 생성 후 호출하거나, scope.Instantiate()가 내부적으로 호출.
+        /// </summary>
+        public static void InjectGameObject(this IScope scope, GameObject gameObject)
+        {
+            if (scope == null || gameObject == null) return;
+
+            var injectables = gameObject.GetComponentsInChildren<IInjectable>(true);
+            foreach (var injectable in injectables)
+            {
+                DependencyInjector.Inject(injectable, scope);
+
+                if (injectable is DIBehaviour dib)
+                    dib.SetInjected(scope);
+            }
+        }
+
+        /// <summary>
+        /// 프리팹 인스턴스화 + 하위 IInjectable 자동 주입.
+        /// Object.Instantiate 대신 사용.
+        /// </summary>
+        public static GameObject Instantiate(this IScope scope, GameObject prefab)
+        {
+            var instance = Object.Instantiate(prefab);
+            scope.InjectGameObject(instance);
+            return instance;
+        }
+
+        /// <summary>
+        /// 프리팹 인스턴스화 (부모 지정) + 하위 IInjectable 자동 주입.
+        /// </summary>
+        public static GameObject Instantiate(this IScope scope, GameObject prefab, Transform parent)
+        {
+            var instance = Object.Instantiate(prefab, parent);
+            scope.InjectGameObject(instance);
+            return instance;
+        }
+
+        /// <summary>
+        /// 프리팹 인스턴스화 (위치/회전 지정) + 하위 IInjectable 자동 주입.
+        /// </summary>
+        public static GameObject Instantiate(this IScope scope, GameObject prefab, Vector3 position, Quaternion rotation)
+        {
+            var instance = Object.Instantiate(prefab, position, rotation);
+            scope.InjectGameObject(instance);
+            return instance;
+        }
+
+        /// <summary>
+        /// 프리팹 인스턴스화 (부모 + 위치/회전 지정) + 하위 IInjectable 자동 주입.
+        /// </summary>
+        public static GameObject Instantiate(this IScope scope, GameObject prefab, Vector3 position, Quaternion rotation, Transform parent)
+        {
+            var instance = Object.Instantiate(prefab, position, rotation, parent);
+            scope.InjectGameObject(instance);
+            return instance;
+        }
+    }
+}

package/Runtime/DI/ScopeExtensions.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1654fc549fddb37409031d27a8a5cc15

package/Runtime/DI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f33d137e7882f564095528b29e26f59f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: