Add attribute to register intances

Author: ManticSic

src/UnityContainerAttributeRegistration/Attribute/RegisterInstanceAttribute.cs

@@ -0,0 +1,39 @@
+using System;
+
+using JetBrains.Annotations;
+
+
+namespace UnityContainerAttributeRegistration.Attribute
+{
+    /// <summary>
+    ///     Mark a property to be registered to an <see cref="Unity.IUnityContainer" />
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property)]
+    public class RegisterInstanceAttribute: System.Attribute
+    {
+        /// <summary>
+        ///     Candidate for registration to <see cref="Unity" />.
+        /// </summary>
+        /// <param name="from"><see cref="Type" /> that will be requested.</param>
+        /// <param name="lifetimeManager">The <see cref="Unity.Lifetime.IInstanceLifetimeManager" /> that controls the lifetime of the returned instance.</param>
+        public RegisterInstanceAttribute([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/RegisterInstanceProviderAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace UnityContainerAttributeRegistration.Attribute
+{
+    /// <summary>
+    ///     Mark a type to be a provider for <see cref="RegisterInstanceAttribute"/>
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class RegisterInstanceProviderAttribute : System.Attribute
+    {
+    }
+}

src/UnityContainerAttributeRegistration/Populator/InstancePopulator.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+using JetBrains.Annotations;
+
+using Unity;
+using Unity.Lifetime;
+
+using UnityContainerAttributeRegistration.Provider;
+using UnityContainerAttributeRegistration.Attribute;
+using UnityContainerAttributeRegistration.Exention;
+
+
+namespace UnityContainerAttributeRegistration.Populator
+{
+    internal class InstancePopulator : Populator
+    {
+        /// <summary>
+        ///     ctor
+        /// </summary>
+        /// <param name="appDomain">Used <see cref="IAssemblyProvider" /> for searching for candidates.</param>
+        public InstancePopulator(IAssemblyProvider appDomain) : base(appDomain)
+        {
+        }
+
+        /// <summary>
+        ///     Populate the passed <paramref name="container" />.
+        /// </summary>
+        /// <param name="container"><see cref="IUnityContainer" /> to populate.</param>
+        /// <returns>Passed <paramref name="container" />.</returns>
+        /// <exception cref="InvalidOperationException">Class type must not be static or abstract.</exception>
+        public override IUnityContainer Populate(IUnityContainer container)
+        {
+            IList<Type> typesWithAttribute = GetTypesWith<RegisterInstanceProviderAttribute>(TypeDefined.Inherit)
+               .ToList();
+
+            IEnumerable<InstanceToRegister> instancesToRegister =
+                typesWithAttribute.SelectMany(providerClassType => GetInstancesToRegisterFor(container, providerClassType));
+
+            foreach(InstanceToRegister instanceToRegister in instancesToRegister)
+            {
+                Type                     type            = instanceToRegister.Type;
+                object                   instance        = instanceToRegister.Instance;
+                IInstanceLifetimeManager lifetimeManager = instanceToRegister.LifetimeManager;
+                container.RegisterInstance(type, instance, lifetimeManager);
+            }
+
+            return container;
+        }
+
+        /// <summary>
+        /// Create a list of <see cref="InstanceToRegister"/> depending on class marked with <see cref="RegisterInstanceProviderAttribute"/>
+        /// </summary>
+        /// <param name="container"><see cref="IUnityContainer"/> to resolve <paramref name="providerClassType"/></param>
+        /// <param name="providerClassType">Class type used to search for <see cref="RegisterInstanceAttribute"/></param>
+        /// <returns>List of instances to register with all needed parameters</returns>
+        /// <exception cref="InvalidOperationException"><paramref name="providerClassType" /> type must not be static or abstract.</exception>
+        private IEnumerable<InstanceToRegister> GetInstancesToRegisterFor(IUnityContainer container, Type providerClassType)
+        {
+            if(providerClassType.IsStatic() || providerClassType.IsAbstract)
+            {
+                throw new InvalidOperationException(
+                    $"Class type must not be static or abstract to be used with RegisterTypeAttribute: {providerClassType.FullName}");
+            }
+
+            object providerClassInstance = container.Resolve(providerClassType);
+            PropertyInfo[] properties = providerClassType.GetProperties();
+
+            return properties.Where(info => info.CustomAttributes.Any(data => data.AttributeType == typeof(RegisterInstanceAttribute)))
+                             .Select(info =>
+                                     {
+                                         object instance = info.GetValue(providerClassInstance);
+                                         RegisterInstanceAttribute attribute = info.GetCustomAttribute<RegisterInstanceAttribute>();
+                                         Type from = attribute.From;
+                                         IInstanceLifetimeManager lifetimeManager = attribute.LifetimeManager == null ? null : GetInstanceByType<IInstanceLifetimeManager>(attribute.LifetimeManager);
+
+                                         return new InstanceToRegister(instance, from, lifetimeManager);
+                                    })
+                             .ToList();
+        }
+
+        /// <summary>
+        /// Wrapper to regsiter isntances
+        /// </summary>
+        private sealed class InstanceToRegister
+        {
+            public InstanceToRegister([CanBeNull] object                   instance,
+                                      [CanBeNull] Type                     type,
+                                      [CanBeNull] IInstanceLifetimeManager lifetimeManager)
+            {
+                Instance        = instance;
+                Type            = type;
+                LifetimeManager = lifetimeManager;
+            }
+
+            /// <summary>
+            /// Concrete instance to register
+            /// </summary>
+            [CanBeNull]
+            public object Instance { get; }
+
+            /// <summary>
+            /// Requested type
+            /// </summary>
+            [CanBeNull]
+            public Type Type { get; }
+
+            /// <summary>
+            /// Used lifetime manager
+            /// </summary>
+            [CanBeNull]
+            public IInstanceLifetimeManager LifetimeManager { get; }
+        }
+    }
+}

src/UnityContainerAttributeRegistration/UnityContainerPopulator.cs

@@ -13,8 +13,8 @@ namespace UnityContainerAttributeRegistration
     /// </summary>
     public sealed class UnityContainerPopulator
     {
-        private readonly IAssemblyProvider appDomain;
-        private readonly IPopulator        TypePopulator;
+        private readonly IPopulator        typePopulator;
+        private readonly IPopulator        instancePopulator;
 
         /// <summary>
         ///     Use <see cref="System.AppDomain.CurrentDomain" /> to populate an <see cref="Unity.IUnityContainer" />
@@ -29,9 +29,8 @@ public UnityContainerPopulator() : this(new AssemblyProvider())
         /// <param name="appDomain">Custom <see cref="IAssemblyProvider" /></param>
         public UnityContainerPopulator([NotNull] IAssemblyProvider appDomain)
         {
-            this.appDomain = appDomain;
-
-            TypePopulator = new TypePopulator(appDomain);
+            typePopulator = new TypePopulator(appDomain);
+            instancePopulator = new InstancePopulator(appDomain);
         }
 
         /// <summary>
@@ -52,7 +51,8 @@ public IUnityContainer Populate()
         /// </returns>
         public IUnityContainer Populate([NotNull] IUnityContainer container)
         {
-            TypePopulator.Populate(container);
+            typePopulator.Populate(container);
+            instancePopulator.Populate(container);
 
             return container;
         }

src/UnityContainerAttributeRegistrationTest/Assets/RegistertInstanceTestClasses/TestClasses.cs

@@ -0,0 +1,99 @@
+using Unity.Lifetime;
+
+using UnityContainerAttributeRegistration.Attribute;
+
+
+namespace UnityContainerAttributeRegistrationTest.Assets.RegistertInstanceTestClasses
+{
+    [RegisterInstanceProvider]
+    public class DefaultProvider
+    {
+        [RegisterInstance]
+        public AnyClass Value
+        {
+            get => new AnyClass();
+        }
+    }
+
+    [RegisterInstanceProvider]
+    public class ProviderUsingFromWithoutLifetimeManager
+    {
+        [RegisterInstance(typeof(IAnyInterface))]
+        public AnyClass Value
+        {
+            get => new AnyClass();
+        }
+    }
+
+    [RegisterInstanceProvider]
+    public class ProviderUsingFromWithSingletonLifetimeManager
+    {
+        [RegisterInstance(typeof(IAnyInterface), typeof(SingletonLifetimeManager))]
+        public AnyClass Value
+        {
+            get => new AnyClass();
+        }
+    }
+
+    [RegisterInstanceProvider]
+    public class ProviderUsingFromWithContainerControlledLifetimeManager
+    {
+        [RegisterInstance(typeof(IAnyInterface), typeof(ContainerControlledLifetimeManager))]
+        public AnyClass Value
+        {
+            get => new AnyClass();
+        }
+    }
+
+    [RegisterInstanceProvider]
+    public class ProviderUsingFromWithExternallyControlledLifetimeManager
+    {
+        [RegisterInstance(typeof(IAnyInterface), typeof(ExternallyControlledLifetimeManager))]
+        public AnyClass Value
+        {
+            get => new AnyClass();
+        }
+    }
+
+    [RegisterInstanceProvider]
+    public class ProviderWithExternallyControlledLifetimeManager
+    {
+        [RegisterInstance(null, typeof(ExternallyControlledLifetimeManager))]
+        public AnyClass Value
+        {
+            get => new AnyClass();
+        }
+    }
+
+    [RegisterInstanceProvider]
+    public class ProviderWithLifetimemanagerWithoutInterface
+    {
+        [RegisterInstance(null, typeof(LifetimeManagerWithoutInterface))]
+        public AnyClass Value
+        {
+            get => new AnyClass();
+        }
+    }
+
+    [RegisterInstanceProvider]
+    public static class StaticClassWithAttribute
+    {
+    }
+
+    [RegisterInstanceProvider]
+    public abstract class AbstractClassWithAttribute
+    {
+    }
+
+    public class AnyClass : IAnyInterface
+    {
+    }
+
+    public interface IAnyInterface
+    {
+    }
+
+    public class LifetimeManagerWithoutInterface
+    {
+    }
+}

src/UnityContainerAttributeRegistrationTest/Attribute/RegisterInstanceAttributeTest.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using NUnit.Framework;
+
+using Unity;
+using Unity.Lifetime;
+
+using UnityContainerAttributeRegistration;
+
+using UnityContainerAttributeRegistrationTest.Assets.RegistertInstanceTestClasses;
+using UnityContainerAttributeRegistrationTest.Helper;
+
+using static NUnit.Framework.Assert;
+
+namespace UnityContainerAttributeRegistrationTest.Attribute
+{
+    public class RegisterInstanceAttributeTest : TestBase
+    {
+        [Test]
+        [TestCase(typeof(DefaultProvider), typeof(AnyClass), typeof(AnyClass), typeof(ContainerControlledLifetimeManager))]
+        [TestCase(typeof(ProviderUsingFromWithoutLifetimeManager), typeof(IAnyInterface), typeof(AnyClass), typeof(ContainerControlledLifetimeManager))]
+        [TestCase(typeof(ProviderUsingFromWithSingletonLifetimeManager), typeof(IAnyInterface), typeof(AnyClass), typeof(SingletonLifetimeManager))]
+        [TestCase(typeof(ProviderUsingFromWithContainerControlledLifetimeManager), typeof(IAnyInterface), typeof(AnyClass), typeof(ContainerControlledLifetimeManager))]
+        [TestCase(typeof(ProviderUsingFromWithExternallyControlledLifetimeManager), typeof(IAnyInterface), typeof(AnyClass), typeof(ExternallyControlledLifetimeManager))]
+        [TestCase(typeof(ProviderWithExternallyControlledLifetimeManager), typeof(AnyClass), typeof(AnyClass), typeof(ExternallyControlledLifetimeManager))]
+        public void TestPopulate(Type providerType, Type expectedFrom, Type expectedTo, Type expectedInstanceLifetimeManagerType)
+        {
+            Scope scope = new Scope();
+
+            scope.AddType(providerType);
+
+            IUnityContainer container = new UnityContainerPopulator(scope.GetAppDomain()).Populate();
+
+            IList<IContainerRegistration> result = container.Registrations.ToArray();
+
+            AreEqual(2, result.Count);
+            IsTrue(IsUnityContainerRegistration(result[0]));
+            IsTrue(IsExpectedRegisteredContainer(result[1], expectedFrom, expectedTo, expectedInstanceLifetimeManagerType));
+        }
+
+        [Test]
+        [TestCase(typeof(StaticClassWithAttribute))]
+        [TestCase(typeof(AbstractClassWithAttribute))]
+        [TestCase(typeof(ProviderWithLifetimemanagerWithoutInterface))]
+        public void TestPopulate_InvalidUsage(Type providerType)
+        {
+            Scope scope = new Scope();
+
+            scope.AddType(providerType);
+
+            Throws<InvalidOperationException>(() => new UnityContainerPopulator(scope.GetAppDomain()).Populate());
+        }
+
+        [Test]
+        public void TestPopulate_WithCustomContainer()
+        {
+            Scope scope = new Scope();
+
+            IUnityContainer container = new UnityContainer();
+
+            IUnityContainer result = new UnityContainerPopulator(scope.GetAppDomain()).Populate(container);
+
+            AreSame(container, result);
+        }
+    }
+}