Merge pull request #8

Version 1.0.1

Framework/Binding/Implemantions/BindingFactory.cs

@@ -25,6 +25,7 @@ namespace EasyJection.Binding
     using Types;
     using Reflection;
     using System.Runtime.CompilerServices;
+    using EasyJection.Binding.Extensions;
 
     /// <summary>
     /// Implementation of the <see cref="IBindingFactory"/> interface
@@ -50,7 +51,7 @@ public BindingFactory(IBinder binder, Type bindingType, IReflectionCache cache)
         }
 
         /// <inheritdoc cref="IBindingFactory.AddBinding(object)"/>
-        public IBindingCondition AddBinding(object value) 
+        public IBindingCondition AddBinding(object value, bool UseDefaultConstructor) 
         {
             var binding = new BindingData(this.BindingType, value, BindingInstanceType.Transient);
             this.Binder.AddBinding(binding);
@@ -60,7 +61,9 @@ public IBindingCondition AddBinding(object value)
                 this.PreCaching(value as Type ?? value.GetType());
 
             var bindInjection = this.CreateBindingInjectionFactoryProvider(binding);
-            bindInjection.Constructor(true);
+
+            if (UseDefaultConstructor)
+                bindInjection.Constructor(true);
 
             return this.CreateBindingConditionFactoryProvider(binding);
         }
@@ -92,19 +95,19 @@ public IBindingInjection AddBinding(object value, BindingInstanceType instanceTy
             return bindInjection;
         }
 
-        /// <inheritdoc cref="IBindingFactory.To{T}()"/>
-        public IBindingCondition To<T>() where T : class
+        /// <inheritdoc cref="IBindingFactory.To{T}(bool)"/>
+        public IBindingCondition To<T>(bool UseDefaultConstructor = false) where T : class
         {
-            return this.To(typeof(T));
+            return this.To(typeof(T), UseDefaultConstructor);
         }
 
-        /// <inheritdoc cref="IBindingFactory.To(Type)"/>
-        public IBindingCondition To(Type type)
+        /// <inheritdoc cref="IBindingFactory.To(Type, bool)"/>
+        public IBindingCondition To(Type type, bool UseDefaultConstructor = false)
         {
             if (!Helper.IsAssignable(this.BindingType, type))
                 throw new Exception(Causes.TYPE_NOT_ASSIGNABLE);
 
-            return this.AddBinding(type);
+            return this.AddBinding(type, UseDefaultConstructor);
         }
 
         /// <inheritdoc cref="IBindingFactory.ToInstance{T}(T)"/>
@@ -154,6 +157,31 @@ public void ToFactory(Types.IFactory instance)
             this.AddFactoryInstance(null, instance);
         }
 
+        /// <inheritdoc cref="IBindingFactory.ToFactory{T}(string)"/>
+        public IBindingInjection ToFactory<T>(string methodName, bool UseDefaultConstructor = false) where T : class
+        {
+            var type = typeof(T);
+            var methodInfo = type.FindMethodByName(methodName);
+            if (methodInfo is null)
+                throw new Exception(string.Format(Causes.METHOD_NOT_FOUND, methodName, type.Name));
+
+            var binding = new BindingData(this.BindingType, type, BindingInstanceType.Factory);
+            binding.Factory = new Factory(methodInfo);
+
+            this.Binder.AddBinding(binding);
+
+            // Precaching
+            if (type != null)
+                this.PreCaching(type);
+
+            var bindInjection = this.CreateBindingInjectionFactoryProvider(binding);
+
+            if (UseDefaultConstructor)
+                bindInjection.Constructor(true);
+
+            return bindInjection;
+        }
+
         /// <inheritdoc cref="IBindingFactory.ToSelf(bool)"/>
         public IBindingInjection ToSelf(bool UseDefaultConstructor = false)
         {

Framework/Binding/Interfaces/IBindingFactory.cs

@@ -143,16 +143,18 @@ public interface IBindingFactory
         /// <summary>
         /// Binds the key type to a type of <typeparamref name="T"/> as a transient.
         /// </summary>
+        /// <param name="UseDefaultConstructor">Specifying the use of the default constructor to create an instance</param>
         /// <typeparam name="T">The type to bind to.</typeparam>
         /// <returns>The binding condition object related to this binding.</returns>
-        IBindingCondition To<T>() where T : class;
+        IBindingCondition To<T>(bool UseDefaultConstructor = false) where T : class;
 
         /// <summary>
         /// Binds the key type to a <paramref name="type"/> as a transient.
         /// </summary>
+        /// <param name="UseDefaultConstructor">Specifying the use of the default constructor to create an instance</param>
         /// <param name="type">The related type.</param>
         /// <returns>The binding condition object related to this binding.</returns>
-        IBindingCondition To(Type type);
+        IBindingCondition To(Type type, bool UseDefaultConstructor = false);
 
         /// <summary>
         /// Binds the key type to an <paramref name="instance"/> of a <typeparamref name="T"/> type.
@@ -175,7 +177,7 @@ public interface IBindingFactory
         /// </summary>
         /// <param name="UseDefaultConstructor">Specifying the use of the default constructor to create an instance</param>
         /// <typeparam name="T">The type which has implemented <see cref="Types.IFactory"/> interface.</typeparam>
-        /// /// <returns>The binding injection object related to this binding.</returns>
+        /// <returns>The binding injection object related to this binding.</returns>
         IBindingInjection ToFactory<T>(bool UseDefaultConstructor = false) where T : Types.IFactory;
 
         /// <summary>
@@ -200,12 +202,22 @@ public interface IBindingFactory
         /// <param name="instance">The instance of a type which has implemented <see cref="Types.IFactory"/> interface.</param>
         void ToFactory(Types.IFactory instance);
 
+        /// <summary>
+        /// Binds the key type to a <typeparamref name="T"/> factory.
+        /// </summary>
+        /// <param name="methodName">The name of the method of your  <typeparamref name="T"/> factory that will create an instance.</param>
+        /// <param name="UseDefaultConstructor">Specifying the use of the default constructor to create an instance of <typeparamref name="T"/> factory.</param>
+        /// <typeparam name="T">The type of your factory.</typeparam>
+        /// <returns>The binding injection object related to this binding.</returns>
+        IBindingInjection ToFactory<T>(string methodName, bool UseDefaultConstructor = false) where T : class;
+
         /// <summary>
         /// Creates a binding.
         /// </summary>
         /// <param name="value">Binding value.</param>
+        /// <param name="UseDefaultConstructor">Specifying the use of the default constructor to create an instance</param>
         /// <returns>The binding injection object related to this binding.</returns>
-        IBindingCondition AddBinding(object value);
+        IBindingCondition AddBinding(object value, bool UseDefaultConstructor);
 
         /// <summary>
         /// Creates a binding.

Framework/CHANGELOG.md

@@ -10,6 +10,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.1] - 2023-02-11
+- Fixed a bug with injection to a default constructor.
+- Added the ability to bind a factory class without an inherited 'EasyJection.Types.IFactory' and specify the method for creating instances by method name.
+
 ## [1.0.0] - 2023-02-11
 - New architecture.
 - Documentation expanded.

Framework/Reflection/Utils/Delegates.cs

@@ -21,6 +21,13 @@
 
 namespace EasyJection.Reflection.Utils
 {
+    #region Comment
+    /// <summary>
+    /// Delegate for the factory's method of creating an instance without parameters.
+    /// </summary>
+    #endregion
+    public delegate object InstantiatorCall(object instance);
+
     #region Comment
     /// <summary>
     /// Delegate for a constructor call without parameters.

Framework/Reflection/Utils/MethodMaker.cs

@@ -130,5 +130,10 @@ public static ParamsMethodCall CreateParameterizedMethod(System.Reflection.Metho
         {
             return (object instance, object[] parameters) => methodInfo.Invoke(instance, parameters);
         }
+
+        public static InstantiatorCall CreateInstantinateMethod(System.Reflection.MethodInfo methodInfo)
+        {
+            return (object instance) => methodInfo.Invoke(instance, null);
+        }
     }
 }

Framework/Resolving/Implementions/Resolver.cs

@@ -120,7 +120,12 @@ public object Resolve(Type type, IDictionary<Type, object> scopedInstances)
             else if (bindingData.InstanceType.HasFlag(BindingInstanceType.Factory))
             {
                 bindingData.InstanceType = BindingInstanceType.Factory | BindingInstanceType.Instance;
-                bindingData.Factory = instance as IFactory;
+
+                if (bindingData.Factory == null)
+                    bindingData.Factory = instance as IFactory;
+                else
+                    (bindingData.Factory as IFectorySetter).SetFactoryinstance(instance);
+
                 return bindingData.Factory.CreateInstance(bindingData);
             }
 

Framework/Types/Factory.cs

@@ -0,0 +1,52 @@
+/*
+ * This file is part of the EasyJection Framework.
+ * Author: Max Karepin (http://github.com/imaxs/)
+ *
+ * Copyright © 2021 Max Karepin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+
+namespace EasyJection.Types
+{
+    using Binding;
+    using Reflection.Utils;
+
+    public interface IFectorySetter
+    {
+        void SetFactoryinstance(object factoryInstance);
+    }
+
+    public class Factory : IFactory, IFectorySetter
+    {
+        protected object factoryInstance;
+        protected InstantiatorCall createInstance;
+        public Factory(System.Reflection.MethodInfo methodInfo) 
+        {
+            this.createInstance = MethodMaker.CreateInstantinateMethod(methodInfo);
+            this.factoryInstance = null;
+        }
+
+        public void SetFactoryinstance(object factoryInstance) 
+        {
+            this.factoryInstance = factoryInstance;
+        }
+
+        public object CreateInstance(IBindingData bindingData = null)
+        {
+            return this.createInstance(this.factoryInstance);
+        }
+    }
+}

UnityPackage/CHANGELOG.md

@@ -11,6 +11,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.1] - 2023-02-11
+- Fixed a bug with injection to a default constructor.
+- Added the ability to bind a factory class without an inherited 'EasyJection.Types.IFactory' and specify the method for creating instances by method name.
+- Added the 'MonoInstaller' abstract class.
+- Updated samples
+
 ## [1.0.0] - 2023-02-11
 - New architecture.
 - Documentation expanded.

UnityPackage/Runtime/Extensions/UnityEngine/Install/MonoInstaller.cs

@@ -28,9 +28,25 @@ namespace EasyJection
 #if UNITY_ENGINE_AVAILABLE
     using UnityEngine;
 
-    public class MonoInstaller : MonoBehaviour
+    public abstract class MonoInstaller : MonoBehaviour
     {
+        protected IContainer Container;
 
+        protected abstract void InstallBindings();
+
+        protected MonoInstaller() 
+        {
+            if (Container == null)
+                Container = new Container();
+
+            this.InstallBindings();
+        }
+
+        protected void OnDestroy()
+        {
+            if (Container != null)
+                Container.Dispose();
+        }
     }
 #endif
 }