refine injector

Author: LoneWandererProductions

Core.Inject/CoreInjector.cs

@@ -8,6 +8,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Core.Inject
 {
@@ -117,6 +118,23 @@ public void RegisterInstance<TService>(TService instance)
             };
         }
 
+        /// <summary>
+        /// Registers the transient.
+        /// </summary>
+        /// <param name="serviceType">Type of the service.</param>
+        /// <param name="implementationType">Type of the implementation.</param>
+        /// <exception cref="System.InvalidOperationException">Service {serviceType.Name} is already registered.</exception>
+        public void RegisterTransient(Type serviceType, Type implementationType)
+        {
+            if (_registrations.ContainsKey(serviceType))
+            {
+                throw new InvalidOperationException($"Service {serviceType.Name} is already registered.");
+            }
+
+            // We store a factory that calls our new CreateInstance method
+            _registrations[serviceType] = () => CreateInstance(implementationType);
+        }
+
         /// <summary>
         ///     Resolves an instance of the requested service type.
         ///     If a scope is active, the service will be resolved within that scope.
@@ -133,6 +151,26 @@ public TService Resolve<TService>()
             return (TService)Resolve(typeof(TService));
         }
 
+        /// <summary>
+        ///     Starts a new dependency scope.
+        ///     Scoped services can be resolved within this scope.
+        /// </summary>
+        public void BeginScope()
+        {
+            _currentScope = new SimpleScope();
+        }
+
+        /// <summary>
+        ///     Ends the current dependency scope.
+        ///     Scoped services will no longer be available after this point.
+        /// </summary>
+        public void EndScope()
+        {
+            _currentScope?.Dispose();
+            _currentScope = null;
+        }
+
+
         /// <summary>
         ///     Resolves a service by its type.
         /// </summary>
@@ -151,22 +189,32 @@ private object Resolve(Type serviceType)
         }
 
         /// <summary>
-        ///     Starts a new dependency scope.
-        ///     Scoped services can be resolved within this scope.
+        /// Creates the instance.
         /// </summary>
-        public void BeginScope()
+        /// <param name="implementationType">Type of the implementation.</param>
+        /// <returns>The created instance.</returns>
+        private object CreateInstance(Type implementationType)
         {
-            _currentScope = new SimpleScope();
-        }
+            // Find the best constructor (for now, we'll just take the first one)
+            var constructor = implementationType.GetConstructors()
+                .OrderByDescending(c => c.GetParameters().Length) // Pick the one with the most params
+                .First();
 
-        /// <summary>
-        ///     Ends the current dependency scope.
-        ///     Scoped services will no longer be available after this point.
-        /// </summary>
-        public void EndScope()
-        {
-            _currentScope?.Dispose();
-            _currentScope = null;
+            var parameters = constructor.GetParameters();
+
+            if (parameters.Length == 0)
+            {
+                return Activator.CreateInstance(implementationType);
+            }
+
+            // Recursively resolve each dependency found in the constructor
+            var parameterInstances = new List<object>();
+            foreach (var parameter in parameters)
+            {
+                parameterInstances.Add(Resolve(parameter.ParameterType));
+            }
+
+            return constructor.Invoke(parameterInstances.ToArray());
         }
     }
 }

Core.Inject/CoreInjectorExtensions.cs

@@ -33,23 +33,12 @@ public static void RegisterFromAssembly(this CoreInjector injector, Assembly ass
                 .Where(t => t.IsClass && !t.IsAbstract)
                 .SelectMany(t => t.GetInterfaces(), (t, i) => new { Implementation = t, Interface = i });
 
-            foreach (var type in types.Where(type => !injector.IsServiceRegistered(type.Interface)))
+            foreach (var type in types)
             {
-                // Try to register the service
-                try
+                if (!injector.IsServiceRegistered(type.Interface))
                 {
-                    var method = typeof(CoreInjector)
-                        .GetMethod(CoreInjectResource.MethodRegisterTransient,
-                            BindingFlags.Public | BindingFlags.Instance)
-                        ?.MakeGenericMethod(type.Interface, type.Implementation);
-
-                    method?.Invoke(injector, null);
-                }
-                catch (InvalidOperationException ex)
-                {
-                    // Log and handle any errors if needed, this should not happen anymore
-                    throw new InvalidOperationException(string.Format(CoreInjectResource.ErrorRegisteringService,
-                        type.Interface.Name, ex.Message));
+                    // Now we call the non-generic version directly!
+                    injector.RegisterTransient(type.Interface, type.Implementation);
                 }
             }
         }