first commit

Author: 7bitcoder

.gitignore

@@ -0,0 +1,3 @@
+/.vscode
+/bin
+/obj

CSharpLibraries.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

DependencyInjector/DependencyInjector.cs

@@ -0,0 +1,90 @@
+namespace CSharpLibraries.DependencyInjector
+{
+    public class DependencyInjector
+    {
+        private HashSet<Type> underConstruction = new();
+        private Dictionary<Type, Type> _typesMap = new();
+        private Dictionary<Type, object> _registeredObjects = new();
+
+        public void AddSingeleton<T>()
+            where T : class
+        {
+            _typesMap[typeof(T)] = typeof(T);
+        }
+
+        public void AddSingeleton<I, T>()
+            where T : I
+            where I : class
+        {
+            _typesMap[typeof(I)] = typeof(T);
+        }
+
+        public T? get<T>() where T : class
+        {
+            return get(typeof(T)) as T;
+        }
+
+        public void build()
+        {
+            foreach (var interfaceType in _typesMap.Keys)
+            {
+                registerObject(interfaceType);
+            }
+        }
+
+        private object registerObject(Type interfaceType)
+        {
+            if (underConstruction.Contains(interfaceType))
+            {
+                throw new InvalidOperationException($"Circular dependency detected in {interfaceType.FullName} constructor");
+            }
+            underConstruction.Add(interfaceType);
+            var obj = createObject(interfaceType);
+            _registeredObjects[interfaceType] = obj;
+            underConstruction.Remove(interfaceType);
+            return obj;
+        }
+
+        private object createObject(Type interfaceType)
+        {
+            var type = _typesMap[interfaceType];
+            List<object> parameters = new();
+            var constructors = type.GetConstructors();
+            if (constructors.Length != 1)
+            {
+                throw new InvalidOperationException($"Class {type.FullName} should have exactly one constructor");
+            }
+            var constructor = constructors.First();
+            var parametersInfo = constructor.GetParameters();
+
+            foreach (var parameterInfo in parametersInfo)
+            {
+                var paramType = parameterInfo.ParameterType;
+                parameters.Add(getParameter(paramType));
+            }
+            return constructor.Invoke(parameters.ToArray());
+        }
+
+        private object getParameter(Type parameterType)
+        {
+            var obj = get(parameterType);
+            if (obj is not null)
+            {
+                return obj;
+            }
+            else
+            {
+                return registerObject(parameterType);
+            }
+        }
+
+        private object? get(Type interfaceType)
+        {
+            if (_registeredObjects.TryGetValue(interfaceType, out var obj))
+            {
+                return obj;
+            }
+            return null;
+        }
+    }
+}

ExampleClassA.cs

@@ -0,0 +1,27 @@
+namespace CSharpLibraries
+{
+    public class ExampleClassA
+    {
+        public int id = 100;
+        public ExampleClassA()
+        {
+            id = 101;
+        }
+
+        public ExampleClassA(int gg)
+        {
+            id = 101;
+        }
+    }
+
+    public class ExampleClassB
+    {
+        public int id = 100;
+        public ExampleClassA obj;
+        public ExampleClassB(ExampleClassA exampleClass)
+        {
+            id = 101;
+            obj = exampleClass;
+        }
+    }
+}

Program.cs

@@ -0,0 +1,13 @@
+using CSharpLibraries.DependencyInjector;
+using CSharpLibraries;
+// See https://aka.ms/new-console-template for more information
+
+var di = new DependencyInjector();
+
+di.AddSingeleton<ExampleClassB>();
+di.AddSingeleton<ExampleClassA>();
+
+di.build();
+
+var objB = di.get<ExampleClassB>();
+var objA = objB.obj;