Add register factory attribute

Author: ManticSic

src/UnityContainerAttributeRegistration/Attribute/RegisterFactoryAttribute.cs

@@ -0,0 +1,39 @@
+using System;
+
+using JetBrains.Annotations;
+
+using Unity.Lifetime;
+
+
+namespace UnityContainerAttributeRegistration.Attribute
+{
+    /// <summary>
+    ///     Mark a method to be registered as factory to an <see cref="Unity.IUnityContainer" />
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method)]
+    public class RegisterFactoryAttribute : System.Attribute
+    {
+        /// <summary>
+        ///     Candidate for registration to <see cref="Unity" />.
+        /// </summary>
+        public RegisterFactoryAttribute([CanBeNull] Type from = null,
+                                        [CanBeNull] Type lifetimeManager = null)
+        {
+            From            = from;
+            LifetimeManager = lifetimeManager;
+        }
+
+        /// <summary>
+        ///     <see cref="Type" /> that will be requested.
+        /// </summary>
+        [CanBeNull]
+        internal Type From { get; }
+
+        /// <summary>
+        ///     The <see cref="LifetimeManager" /> that controls the lifetime
+        ///     of the returned instance.
+        /// </summary>
+        [CanBeNull]
+        internal Type LifetimeManager { get; }
+    }
+}

src/UnityContainerAttributeRegistration/Attribute/RegisterProviderAttribute.cs

@@ -4,7 +4,7 @@
 namespace UnityContainerAttributeRegistration.Attribute
 {
     /// <summary>
-    ///     Mark a type to be a provider for <see cref="RegisterInstanceAttribute" />
+    ///     Mark a type to be a provider for <see cref="RegisterInstanceAttribute" /> and <see cref="RegisterFactoryAttribute" />
     /// </summary>
     [AttributeUsage(AttributeTargets.Class)]
     public class RegisterProviderAttribute : System.Attribute

src/UnityContainerAttributeRegistration/Populator/FactoryPopulator.cs

@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+using JetBrains.Annotations;
+
+using Unity;
+using Unity.Lifetime;
+
+using UnityContainerAttributeRegistration.Attribute;
+using UnityContainerAttributeRegistration.Exention;
+using UnityContainerAttributeRegistration.Provider;
+
+
+namespace UnityContainerAttributeRegistration.Populator
+{
+    internal class FactoryPopulator : Populator
+    {
+        public FactoryPopulator(IAssemblyProvider assemblyProvider) : base(assemblyProvider)
+        {
+        }
+
+        public override IUnityContainer Populate(IUnityContainer container)
+        {
+            IList<Type> typesWithAttribute = GetTypesWith<RegisterProviderAttribute>(TypeDefined.Inherit)
+               .ToList();
+
+            IEnumerable<FactoryToRegister> factoriesToRegister =
+                typesWithAttribute.SelectMany(providerClassType => GetInstancesToRegisterFor(container, providerClassType));
+
+            foreach(FactoryToRegister factoryToRegister in factoriesToRegister)
+            {
+                Type                                        returnType = factoryToRegister.ReturnType;
+                Func<IUnityContainer, Type, string, object> factory    = factoryToRegister.Factory;
+                IFactoryLifetimeManager lifetimeManager = factoryToRegister.LifetimeManager;
+
+                container.RegisterFactory(returnType, factory, lifetimeManager);
+            }
+
+            return container;
+        }
+
+        private IEnumerable<FactoryToRegister> GetInstancesToRegisterFor(IUnityContainer container, Type providerClassType)
+        {
+            if(providerClassType.IsStatic() || providerClassType.IsAbstract)
+            {
+                // todo is not covered, exception is thrown by another populator
+                throw new InvalidOperationException(
+                    $"Class type must not be static or abstract to be used with RegisterTypeAttribute: {providerClassType.FullName}");
+            }
+
+            object       providerClassInstance = container.Resolve(providerClassType);
+            MethodInfo[] methodInfos            = providerClassType.GetMethods();
+
+            return methodInfos
+                  .Where(info => info.CustomAttributes.Any(data => data.AttributeType == typeof(RegisterFactoryAttribute)))
+                  .Select(info => CreateFactoryToRegisterFrom(info, providerClassInstance))
+                  .ToList();
+        }
+
+        private FactoryToRegister CreateFactoryToRegisterFrom(MethodInfo info, object instance)
+        {
+            RegisterFactoryAttribute attribute  = info.GetCustomAttribute<RegisterFactoryAttribute>();
+            Type                     returnType = attribute.From ?? info.ReturnType;
+
+            if(returnType == typeof(void))
+            {
+                throw new InvalidOperationException("Return type must not be void.");
+            }
+
+            if(!IsUnityFactorySignatur(info))
+            {
+                throw new InvalidOperationException("Factory method signature does not match.");
+            }
+
+            IFactoryLifetimeManager lifetimeManager =
+                attribute.LifetimeManager == null
+                    ? null
+                    : GetInstanceByType<IFactoryLifetimeManager>(attribute.LifetimeManager);
+
+
+            return new FactoryToRegister(returnType, GetFactoryMethodFor(info, instance), lifetimeManager);
+        }
+
+        private bool IsUnityFactorySignatur(MethodInfo methodInfo)
+        {
+            var parameters = methodInfo.GetParameters();
+
+            if(parameters.Length == 1
+                && parameters[0].ParameterType == typeof(IUnityContainer)
+               )
+            {
+                return true;
+            }
+
+            if(parameters.Length == 3
+            && parameters[0].ParameterType == typeof(IUnityContainer)
+            && parameters[1].ParameterType == typeof(Type)
+            && parameters[2].ParameterType == typeof(string)
+            )
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private Func<IUnityContainer, Type, string, object> GetFactoryMethodFor(MethodInfo methodInfo, object instance)
+        {
+            return (container, typeValue, stringValue) => {
+                       IList<object> invokeParams = new List<object>{container};
+
+                       if(methodInfo.GetParameters().Length == 3)
+                       {
+                           invokeParams.Add(typeValue);
+                           invokeParams.Add(stringValue);
+                       }
+
+                       return methodInfo.Invoke(instance, invokeParams.ToArray());
+                   };
+        }
+
+        private sealed class FactoryToRegister
+        {
+            public FactoryToRegister([NotNull] Type returnType, [NotNull] Func<IUnityContainer, Type, string, object> factory, [CanBeNull] IFactoryLifetimeManager lifetimeManager)
+            {
+                ReturnType           = returnType;
+                Factory              = factory;
+                LifetimeManager = lifetimeManager;
+            }
+
+            [NotNull]
+            public Type ReturnType { get; }
+
+            [NotNull]
+            public Func<IUnityContainer, Type, string, object> Factory { get; }
+
+            [CanBeNull]
+            public IFactoryLifetimeManager LifetimeManager { get; }
+        }
+    }
+}

src/UnityContainerAttributeRegistration/UnityContainerPopulator.cs

@@ -15,6 +15,7 @@ public sealed class UnityContainerPopulator
     {
         private readonly IPopulator typePopulator;
         private readonly IPopulator instancePopulator;
+        private readonly IPopulator factoryPopulator;
 
         /// <summary>
         ///     Use <see cref="System.AppDomain.CurrentDomain" /> to populate an <see cref="Unity.IUnityContainer" />
@@ -31,6 +32,7 @@ public UnityContainerPopulator([NotNull] IAssemblyProvider appDomain)
         {
             typePopulator     = new TypePopulator(appDomain);
             instancePopulator = new InstancePopulator(appDomain);
+            factoryPopulator  = new FactoryPopulator(appDomain);
         }
 
         /// <summary>
@@ -53,6 +55,7 @@ public IUnityContainer Populate([NotNull] IUnityContainer container)
         {
             typePopulator.Populate(container);
             instancePopulator.Populate(container);
+            factoryPopulator.Populate(container);
 
             return container;
         }