Code cleanup

Author: ManticSic

src/UnityContainerAttributeRegistration/Adapter/AppDomainAdapter.cs

@@ -5,10 +5,10 @@
 
 namespace UnityContainerAttributeRegistration.Adapter
 {
-    /// <inheritdoc cref="IAppDomainAdapter"/>
+    /// <inheritdoc cref="IAppDomainAdapter" />
     internal class AppDomainAdapter : IAppDomainAdapter
     {
-        /// <inheritdoc cref="IAppDomainAdapter.GetAssemblies"/>
+        /// <inheritdoc cref="IAppDomainAdapter.GetAssemblies" />
         public IList<Assembly> GetAssemblies()
         {
             return AppDomain.CurrentDomain.GetAssemblies();

src/UnityContainerAttributeRegistration/Adapter/IAppDomainAdapter.cs

@@ -5,14 +5,14 @@
 namespace UnityContainerAttributeRegistration.Adapter
 {
     /// <summary>
-    /// Wrapper to provide <see cref="IList{Assembly}"/> instead of using <see cref="System.AppDomain"/>.
+    ///     Wrapper to provide <see cref="IList{T}" /> instead of using <see cref="System.AppDomain" />.
     /// </summary>
     public interface IAppDomainAdapter
     {
         /// <summary>
-        /// Provide <see cref="Assembly"/>s of an AppDomain.
+        ///     Provide <see cref="Assembly" />s of an AppDomain.
         /// </summary>
-        /// <returns><see cref="Assembly"/>s which are used to populate.</returns>
+        /// <returns><see cref="Assembly" />s which are used to populate.</returns>
         public IList<Assembly> GetAssemblies();
     }
 }

src/UnityContainerAttributeRegistration/Attribute/RegisterTypeAttribute.cs

@@ -6,16 +6,16 @@
 namespace UnityContainerAttributeRegistration.Attribute
 {
     /// <summary>
-    /// Mark a class to be registered to an <see cref="Unity.IUnityContainer"/>
+    ///     Mark a class to be registered to an <see cref="Unity.IUnityContainer" />
     /// </summary>
     [AttributeUsage(AttributeTargets.Class)]
     public class RegisterTypeAttribute : System.Attribute
     {
         /// <summary>
-        /// Candidate class for registration to <see cref="Unity"/>.
+        ///     Candidate class 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.ITypeLifetimeManager"/> that controls the lifetime of the returned instance.</param>
+        /// <param name="from"><see cref="Type" /> that will be requested.</param>
+        /// <param name="lifetimeManager">The <see cref="Unity.Lifetime.ITypeLifetimeManager" /> that controls the lifetime of the returned instance.</param>
         public RegisterTypeAttribute([CanBeNull] Type from            = null,
                                      [CanBeNull] Type lifetimeManager = null)
         {
@@ -24,14 +24,14 @@ public RegisterTypeAttribute([CanBeNull] Type from            = null,
         }
 
         /// <summary>
-        /// <see cref="Type"/> that will be requested.
+        ///     <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.
+        ///     The <see cref="LifetimeManager" /> that controls the lifetime
+        ///     of the returned instance.
         /// </summary>
         [CanBeNull]
         internal Type LifetimeManager { get; }

src/UnityContainerAttributeRegistration/Exention/TypeExtension.cs

@@ -4,14 +4,14 @@
 namespace UnityContainerAttributeRegistration.Exention
 {
     /// <summary>
-    /// Extensions for <see cref="Type"/>.
+    ///     Extensions for <see cref="Type" />.
     /// </summary>
     internal static class TypeExtension
     {
         /// <summary>
-        /// Checks if a type is static.
+        ///     Checks if a type is static.
         /// </summary>
-        /// <param name="self"><see cref="Type"/> to be checked.</param>
+        /// <param name="self"><see cref="Type" /> to be checked.</param>
         /// <returns>whether a type is static or not.</returns>
         public static bool IsStatic(this Type self)
         {

src/UnityContainerAttributeRegistration/Populator/IPopulator.cs

@@ -4,15 +4,15 @@
 namespace UnityContainerAttributeRegistration.Populator
 {
     /// <summary>
-    /// Interface for internal populators.
+    ///     Interface for internal populators.
     /// </summary>
     internal interface IPopulator
     {
         /// <summary>
-        /// Populate the passed <paramref name="container"/>.
+        ///     Populate the passed <paramref name="container" />.
         /// </summary>
-        /// <param name="container"><see cref="IUnityContainer"/> to populate.</param>
-        /// <returns>Passed <paramref name="container"/>.</returns>
+        /// <param name="container"><see cref="IUnityContainer" /> to populate.</param>
+        /// <returns>Passed <paramref name="container" />.</returns>
         public IUnityContainer Populate(IUnityContainer container);
     }
 }

src/UnityContainerAttributeRegistration/Populator/Populator.cs

@@ -10,30 +10,30 @@
 namespace UnityContainerAttributeRegistration.Populator
 {
     /// <summary>
-    /// <see cref="IPopulator"/> providing some basic functionality for reflection.
+    ///     <see cref="IPopulator" /> providing some basic functionality for reflection.
     /// </summary>
     internal abstract class Populator : IPopulator
     {
         private readonly IAppDomainAdapter appDomain;
 
         /// <summary>
-        /// ctor
+        ///     ctor
         /// </summary>
-        /// <param name="appDomain">Used <see cref="IAppDomainAdapter"/> for searching for candidates.</param>
+        /// <param name="appDomain">Used <see cref="IAppDomainAdapter" /> for searching for candidates.</param>
         protected Populator(IAppDomainAdapter appDomain)
         {
             this.appDomain = appDomain;
         }
 
-        /// <inheritdoc cref="IPopulator.Populate"/>
+        /// <inheritdoc cref="IPopulator.Populate" />
         public abstract IUnityContainer Populate(IUnityContainer container);
 
         /// <summary>
-        /// Find all types using <typeparamref name="TAttribute"/>.
+        ///     Find all types using <typeparamref name="TAttribute" />.
         /// </summary>
         /// <param name="typeDefined">Using inheritance or not.</param>
-        /// <typeparam name="TAttribute"><see cref="System.Attribute"/> used by searched <see cref="Type"/>s.</typeparam>
-        /// <returns>List of all <see cref="Type"/>s in an <see cref="IAppDomainAdapter"/> using <typeparamref name="TAttribute"/>.</returns>
+        /// <typeparam name="TAttribute"><see cref="System.Attribute" /> used by searched <see cref="Type" />s.</typeparam>
+        /// <returns>List of all <see cref="Type" />s in an <see cref="IAppDomainAdapter" /> using <typeparamref name="TAttribute" />.</returns>
         protected IEnumerable<Type> GetTypesWith<TAttribute>(TypeDefined typeDefined) where TAttribute : System.Attribute
         {
             return appDomain.GetAssemblies()

src/UnityContainerAttributeRegistration/Populator/TypePopulator.cs

@@ -16,25 +16,25 @@
 namespace UnityContainerAttributeRegistration.Populator
 {
     /// <summary>
-    /// Populator for the <see cref="UnityContainerAttributeRegistration.Attribute.RegisterTypeAttribute"/>.
+    ///     Populator for the <see cref="UnityContainerAttributeRegistration.Attribute.RegisterTypeAttribute" />.
     /// </summary>
     internal class TypePopulator : Populator
     {
         /// <summary>
-        /// ctor
+        ///     ctor
         /// </summary>
         /// <param name="appDomain">
-        /// Used <see cref="IAppDomainAdapter"/> to find all candidates using <see cref="RegisterTypeAttribute"/>
+        ///     Used <see cref="IAppDomainAdapter" /> to find all candidates using <see cref="RegisterTypeAttribute" />
         /// </param>
         public TypePopulator(IAppDomainAdapter appDomain) : base(appDomain)
         {
         }
 
         /// <summary>
-        /// Populate the passed <paramref name="container"/>.
+        ///     Populate the passed <paramref name="container" />.
         /// </summary>
-        /// <param name="container"><see cref="IUnityContainer"/> to populate.</param>
-        /// <returns>Passed <paramref name="container"/>.</returns>
+        /// <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)
         {
@@ -45,7 +45,8 @@ public override IUnityContainer Populate(IUnityContainer container)
             {
                 if(to.IsStatic() || to.IsAbstract)
                 {
-                    throw new InvalidOperationException($"Class type must not be static or abstract to be used with RegisterTypeAttribute: {to.FullName}");
+                    throw new InvalidOperationException(
+                        $"Class type must not be static or abstract to be used with RegisterTypeAttribute: {to.FullName}");
                 }
 
                 RegisterTypeAttribute attribute = to.GetCustomAttribute<RegisterTypeAttribute>();
@@ -60,21 +61,20 @@ public override IUnityContainer Populate(IUnityContainer container)
         }
 
         /// <summary>
-        /// Create an instance for <paramref name="objectType"/>.
+        ///     Create an instance for <paramref name="objectType" />.
         /// </summary>
-        /// <param name="objectType"><see cref="Type"/> used to create an instance.</param>
-        /// <typeparam name="T"><paramref name="objectType"/> must be type-equal to, inherit or implement <typeparamref name="T"/>.</typeparam>
-        /// <returns>New instance of <paramref name="objectType"/> as <typeparamref name="T"/>.</returns>
-        /// <exception cref="InvalidOperationException">Cannot create an instance of <paramref name="objectType" />. Whether <paramref name="objectType"/> is not type-equal, does not inherit or implement <typeparamref name="T"/> or has no default constructor.</exception>
+        /// <param name="objectType"><see cref="Type" /> used to create an instance.</param>
+        /// <typeparam name="T"><paramref name="objectType" /> must be type-equal to, inherit or implement <typeparamref name="T" />.</typeparam>
+        /// <returns>New instance of <paramref name="objectType" /> as <typeparamref name="T" />.</returns>
+        /// <exception cref="InvalidOperationException">Cannot create an instance of <paramref name="objectType" />. Whether <paramref name="objectType" /> is not type-equal, does not inherit or implement <typeparamref name="T" /> or has no default constructor.</exception>
         [NotNull]
         private T GetInstanceByType<T>([NotNull] Type objectType)
         {
             Type targetType = typeof(T);
 
             if(!targetType.IsAssignableFrom(objectType))
             {
-                throw new InvalidOperationException(
-                    $"Type {objectType.FullName} cannot be assigned from {targetType.FullName}");
+                throw new InvalidOperationException($"Type {objectType.FullName} cannot be assigned from {targetType.FullName}");
             }
 
             ConstructorInfo ctor = objectType.GetConstructor(Type.EmptyTypes);

src/UnityContainerAttributeRegistration/TypeDefined.cs

@@ -1,16 +1,17 @@
 namespace UnityContainerAttributeRegistration
 {
     /// <summary>
-    /// Enum to avoid booleans.
+    ///     Enum to avoid booleans.
     /// </summary>
     internal enum TypeDefined
     {
         /// <summary>
-        /// Include inheritance.
+        ///     Include inheritance.
         /// </summary>
         Inherit,
+
         /// <summary>
-        /// Not include inheritance.
+        ///     Not include inheritance.
         /// </summary>
         NotInherit
     }

src/UnityContainerAttributeRegistration/UnityContainerPopulator.cs

@@ -1,39 +1,32 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-
-using JetBrains.Annotations;
+using JetBrains.Annotations;
 
 using Unity;
-using Unity.Lifetime;
 
 using UnityContainerAttributeRegistration.Adapter;
-using UnityContainerAttributeRegistration.Attribute;
 using UnityContainerAttributeRegistration.Populator;
 
 
 namespace UnityContainerAttributeRegistration
 {
     /// <summary>
-    /// Creates a populated or populates an <see cref="Unity.IUnityContainer" />, depending on the provided assemblies
+    ///     Creates a populated or populates an <see cref="Unity.IUnityContainer" />, depending on the provided assemblies
     /// </summary>
     public sealed class UnityContainerPopulator
     {
         private readonly IAppDomainAdapter appDomain;
-        private readonly IPopulator TypePopulator;
+        private readonly IPopulator        TypePopulator;
 
         /// <summary>
-        /// Use <see cref="System.AppDomain.CurrentDomain"/> to populate an <see cref="Unity.IUnityContainer" />
+        ///     Use <see cref="System.AppDomain.CurrentDomain" /> to populate an <see cref="Unity.IUnityContainer" />
         /// </summary>
         public UnityContainerPopulator() : this(new AppDomainAdapter())
         {
         }
 
         /// <summary>
-        /// Use <paramref name="appDomain"/> to populate an <see cref="Unity.IUnityContainer" />
+        ///     Use <paramref name="appDomain" /> to populate an <see cref="Unity.IUnityContainer" />
         /// </summary>
-        /// <param name="appDomain">Custom <see cref="UnityContainerAttributeRegistration.Adapter.IAppDomainAdapter"/></param>
+        /// <param name="appDomain">Custom <see cref="UnityContainerAttributeRegistration.Adapter.IAppDomainAdapter" /></param>
         public UnityContainerPopulator([NotNull] IAppDomainAdapter appDomain)
         {
             this.appDomain = appDomain;
@@ -42,19 +35,21 @@ public UnityContainerPopulator([NotNull] IAppDomainAdapter appDomain)
         }
 
         /// <summary>
-        /// Create and populate a new <see cref="Unity.UnityContainer"/>
+        ///     Create and populate a new <see cref="Unity.UnityContainer" />
         /// </summary>
-        /// <returns>New <see cref="Unity.UnityContainer"/> with registered types</returns>
+        /// <returns>New <see cref="Unity.UnityContainer" /> with registered types</returns>
         public IUnityContainer Populate()
         {
             return Populate(new UnityContainer());
         }
 
         /// <summary>
-        /// Populate <paramref name="container"/>
+        ///     Populate <paramref name="container" />
         /// </summary>
-        /// <param name="container"><see cref="Unity.IUnityContainer"/> to register types</param>
-        /// <returns><paramref name="container"/></returns>
+        /// <param name="container"><see cref="Unity.IUnityContainer" /> to register types</param>
+        /// <returns>
+        ///     <paramref name="container" />
+        /// </returns>
         public IUnityContainer Populate([NotNull] IUnityContainer container)
         {
             TypePopulator.Populate(container);

src/UnityContainerAttributeRegistrationTest/Attribute/RegisterInstanceAttributeTest.cs

@@ -1,17 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
-
-using Moq;
 
 using NUnit.Framework;
 
 using Unity;
 using Unity.Lifetime;
 
 using UnityContainerAttributeRegistration;
-using UnityContainerAttributeRegistration.Adapter;
 
 using UnityContainerAttributeRegistrationTest.Assets.RegisterTypeTestClasses;
 using UnityContainerAttributeRegistrationTest.Helper;
@@ -25,17 +21,26 @@ internal class RegisterInstanceAttributeTest
     {
         [Test]
         [TestCase(typeof(Default), typeof(Default), typeof(TransientLifetimeManager))]
-        [TestCase(typeof(ClassImplementsInterfaceWithoutLifetimeManager), typeof(IAnyInterface), typeof(TransientLifetimeManager))]
+        [TestCase(typeof(ClassImplementsInterfaceWithoutLifetimeManager), typeof(IAnyInterface),
+                  typeof(TransientLifetimeManager))]
         [TestCase(typeof(ClassInheritAbstractWithoutLifetimeManager), typeof(AnyAbstractClass), typeof(TransientLifetimeManager))]
         [TestCase(typeof(ClassInheritClassWithoutLifetimeManager), typeof(AnyClass), typeof(TransientLifetimeManager))]
-        [TestCase(typeof(ClassImplementsInterfaceWithHierarchicalLifetimeManager), typeof(IAnyInterface), typeof(HierarchicalLifetimeManager))]
-        [TestCase(typeof(ClassImplementsInterfaceWithSingletonLifetimeManager), typeof(IAnyInterface), typeof(SingletonLifetimeManager))]
-        [TestCase(typeof(ClassImplementsInterfaceWithTransientLifetimeManager), typeof(IAnyInterface), typeof(TransientLifetimeManager))]
-        [TestCase(typeof(ClassImplementsInterfaceWithContainerControlledLifetimeManager), typeof(IAnyInterface), typeof(ContainerControlledLifetimeManager))]
-        [TestCase(typeof(ClassImplementsInterfaceWithContainerControlledTransientManager), typeof(IAnyInterface), typeof(ContainerControlledTransientManager))]
-        [TestCase(typeof(ClassImplementsInterfaceWithExternallyControlledLifetimeManager), typeof(IAnyInterface), typeof(ExternallyControlledLifetimeManager))]
-        [TestCase(typeof(ClassImplementsInterfaceWithPerResolveLifetimeManager),typeof(IAnyInterface),  typeof(PerResolveLifetimeManager))]
-        [TestCase(typeof(ClassImplementsInterfaceWithPerThreadLifetimeManager),typeof(IAnyInterface),  typeof(PerThreadLifetimeManager))]
+        [TestCase(typeof(ClassImplementsInterfaceWithHierarchicalLifetimeManager), typeof(IAnyInterface),
+                  typeof(HierarchicalLifetimeManager))]
+        [TestCase(typeof(ClassImplementsInterfaceWithSingletonLifetimeManager), typeof(IAnyInterface),
+                  typeof(SingletonLifetimeManager))]
+        [TestCase(typeof(ClassImplementsInterfaceWithTransientLifetimeManager), typeof(IAnyInterface),
+                  typeof(TransientLifetimeManager))]
+        [TestCase(typeof(ClassImplementsInterfaceWithContainerControlledLifetimeManager), typeof(IAnyInterface),
+                  typeof(ContainerControlledLifetimeManager))]
+        [TestCase(typeof(ClassImplementsInterfaceWithContainerControlledTransientManager), typeof(IAnyInterface),
+                  typeof(ContainerControlledTransientManager))]
+        [TestCase(typeof(ClassImplementsInterfaceWithExternallyControlledLifetimeManager), typeof(IAnyInterface),
+                  typeof(ExternallyControlledLifetimeManager))]
+        [TestCase(typeof(ClassImplementsInterfaceWithPerResolveLifetimeManager), typeof(IAnyInterface),
+                  typeof(PerResolveLifetimeManager))]
+        [TestCase(typeof(ClassImplementsInterfaceWithPerThreadLifetimeManager), typeof(IAnyInterface),
+                  typeof(PerThreadLifetimeManager))]
         [TestCase(typeof(ClassWithLifetimeManager), typeof(ClassWithLifetimeManager), typeof(TransientLifetimeManager))]
         public void TestPopulate(Type to, Type expectedFrom, Type expectedTypeLifetimeMangerType)
         {