Release 2021.9.21

Author: Alexander Plotnikov

.gitignore

@@ -0,0 +1,14 @@
+{
+    "name": "MicroLibs.Moeda",
+    "rootNamespace": "MicroLibs.Moeda",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

MicroLibs.Moeda.asmdef

@@ -0,0 +1,18 @@
+using System;
+
+namespace MicroLibs.Moeda.Factories
+{
+    internal class Factory<TResult> : IFactory<TResult>
+    {
+        private readonly Func<IScope, TResult> _func;
+
+        public Factory(Func<IScope, TResult> func) {
+            _func = func;
+        }
+
+        public virtual TResult Get(IScope scope)
+        {
+            return _func.Invoke(scope);
+        }
+    }
+}

Source/Factories/Factory.cs

@@ -0,0 +1,8 @@
+namespace MicroLibs.Moeda.Factories
+{
+    internal interface IFactory<TResult> {
+
+        TResult Get(IScope scope);
+
+    }
+}

Source/Factories/IFactory.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace MicroLibs.Moeda.Factories
+{
+    internal class SingleFactory<TResult> : Factory<TResult>
+    {
+        private TResult _value;
+
+        public SingleFactory(Func<IScope, TResult> func) : base(func) {
+
+        }
+        public override TResult Get(IScope scope)
+        {
+            if(_value == null) {
+                _value = base.Get(scope);
+            }
+            return _value;
+        }
+    }
+}

Source/Factories/SingleFactory.cs

@@ -0,0 +1,7 @@
+namespace MicroLibs.Moeda
+{
+    public interface IScope
+    {
+        public TResult Get<TResult>();
+    }
+}

Source/IScope.cs

@@ -0,0 +1,14 @@
+using System;
+using MicroLibs.Moeda.Qualifiers;
+
+namespace MicroLibs.Moeda
+{
+    internal static class IndexKeyUtils
+    {
+        public static string CreateKey(Type type, IQualifier qualifier)
+        {
+            var qualifierValue = qualifier != null ? $":q:{qualifier.Value}" : "";
+            return $"t:{type.FullName}{qualifierValue}";
+        }
+    }
+}

Source/IndexKeyUtils.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using MicroLibs.Moeda.Factories;
+using MicroLibs.Moeda.Qualifiers;
+
+namespace MicroLibs.Moeda
+{
+    public class Module {
+        
+        private readonly Dictionary<string, object> _dictionary = new Dictionary<string, object>();
+
+        public void Single<TResult>(Func<IScope, TResult> action, IQualifier qualifier = null)
+        {
+            var key = CreateKey(typeof(TResult), qualifier);
+            _dictionary[key] = new SingleFactory<TResult>(action);
+        }
+
+        public void Factory<TResult>(Func<IScope, TResult> action, IQualifier qualifier = null) {
+            var key = CreateKey(typeof(TResult), qualifier);
+            _dictionary[key] = new Factory<TResult>(action);
+        }
+
+        internal Dictionary<string, object> GetDictionary()
+        {
+            return _dictionary;
+        }
+
+        private static string CreateKey(Type type, IQualifier qualifier)
+        {
+            return IndexKeyUtils.CreateKey(type, qualifier);
+        }
+    }
+}

Source/Module.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using MicroLibs.Moeda.Factories;
+using MicroLibs.Moeda.Qualifiers;
+using UnityEngine;
+
+namespace MicroLibs.Moeda
+{
+    public class MoedaApp
+    {
+        
+        private readonly Dictionary<string, object> _dictionary = new Dictionary<string, object>();
+        private readonly Dictionary<Type, Module> _modules = new Dictionary<Type, Module>();
+
+        private readonly IScope _scope;
+
+        public MoedaApp()
+        {
+            _scope = new Scope(this);
+        }
+
+        public void Load(Module module)
+        {
+            foreach (var value in module.GetDictionary())
+            {
+                if (_dictionary.ContainsKey(value.Key))
+                {
+                    throw new Exception($"Duplicate object {value.Key}");
+                }
+
+                _dictionary[value.Key] = value.Value;
+            }
+
+            _modules[module.GetType()] = module;
+        }
+
+        public void Unload<T>() where T: Module
+        {
+            var module = _modules[typeof(T)];
+            if (module == null)
+            {
+                Debug.Log($"Not found {typeof(T)}");
+                return;
+            }
+            foreach (var value in module.GetDictionary())
+            {
+                _dictionary.Remove(value.Key);
+            }
+        }
+
+        public TResult Inject<TResult>(IQualifier qualifier = null) {
+            return Get<TResult>(qualifier);
+        }
+
+        public Lazy<TResult> InjectLazy<TResult>(IQualifier qualifier = null) {
+            return new Lazy<TResult>(() => Get<TResult>(qualifier));
+        }
+
+        internal TResult Get<TResult>(IQualifier qualifier = null)
+        {
+            var key = CreateKey(typeof(TResult), qualifier);
+            return ((IFactory<TResult>)_dictionary[key]).Get(_scope);
+        }
+
+        private static string CreateKey(Type type, IQualifier qualifier)
+        {
+            return IndexKeyUtils.CreateKey(type, qualifier);
+        }
+    }
+}

Source/MoedaApp.cs

@@ -0,0 +1,7 @@
+namespace MicroLibs.Moeda.Qualifiers
+{
+    public interface IQualifier
+    {
+        public string Value { get; }
+    }
+}

Source/Qualifiers/IQualifier.cs

@@ -0,0 +1,12 @@
+namespace MicroLibs.Moeda.Qualifiers
+{
+    public class Qualifier : IQualifier
+    {
+        public string Value { get; }
+
+        public Qualifier(string value)
+        {
+            Value = value;
+        }
+    }
+}

Source/Qualifiers/Qualifier.cs

@@ -0,0 +1,18 @@
+namespace MicroLibs.Moeda
+{
+    public class Scope : IScope
+    {
+        private readonly MoedaApp _moedaApp;
+
+        public Scope(MoedaApp moedaApp)
+        {
+            _moedaApp = moedaApp;
+        }
+
+
+        public TResult Get<TResult>()
+        {
+            return _moedaApp.Get<TResult>();
+        }
+    }
+}

Source/Scope.cs

@@ -0,0 +1,13 @@
+{
+    "name": "microlibs.moeda",
+    "author": "Alexander Plotnikov",
+    "displayName": "Moeda",
+    "description": "Dependency Injection Framework",
+    "unity": "2020.3",
+    "version": "2021.9.21",
+    "keywords": [
+        "DI",
+        "Moeda"
+    ],
+    "dependencies": {}
+}