Code cleanup

Author: ManticSic

src/UnityContainerAttributeRegistration/Attribute/RegisterInstanceAttribute.cs

@@ -9,7 +9,7 @@ namespace UnityContainerAttributeRegistration.Attribute
     ///     Mark a property to be registered to an <see cref="Unity.IUnityContainer" />
     /// </summary>
     [AttributeUsage(AttributeTargets.Property)]
-    public class RegisterInstanceAttribute: System.Attribute
+    public class RegisterInstanceAttribute : System.Attribute
     {
         /// <summary>
         ///     Candidate for registration to <see cref="Unity" />.

src/UnityContainerAttributeRegistration/Attribute/RegisterInstanceProviderAttribute.cs

@@ -1,9 +1,10 @@
 using System;
 
+
 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" />
     /// </summary>
     [AttributeUsage(AttributeTargets.Class)]
     public class RegisterInstanceProviderAttribute : System.Attribute

src/UnityContainerAttributeRegistration/Populator/InstancePopulator.cs

@@ -51,10 +51,10 @@ public override IUnityContainer Populate(IUnityContainer container)
         }
 
         /// <summary>
-        /// Create a list of <see cref="InstanceToRegister"/> depending on class marked with <see cref="RegisterInstanceProviderAttribute"/>
+        ///     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>
+        /// <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)
@@ -65,24 +65,28 @@ private IEnumerable<InstanceToRegister> GetInstancesToRegisterFor(IUnityContaine
                     $"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();
+            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
+        ///     Wrapper to regsiter isntances
         /// </summary>
         private sealed class InstanceToRegister
         {
@@ -96,19 +100,19 @@ public InstanceToRegister([CanBeNull] object                   instance,
             }
 
             /// <summary>
-            /// Concrete instance to register
+            ///     Concrete instance to register
             /// </summary>
             [CanBeNull]
             public object Instance { get; }
 
             /// <summary>
-            /// Requested type
+            ///     Requested type
             /// </summary>
             [CanBeNull]
             public Type Type { get; }
 
             /// <summary>
-            /// Used lifetime manager
+            ///     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 IPopulator        typePopulator;
-        private readonly IPopulator        instancePopulator;
+        private readonly IPopulator typePopulator;
+        private readonly IPopulator instancePopulator;
 
         /// <summary>
         ///     Use <see cref="System.AppDomain.CurrentDomain" /> to populate an <see cref="Unity.IUnityContainer" />
@@ -29,7 +29,7 @@ public UnityContainerPopulator() : this(new AssemblyProvider())
         /// <param name="appDomain">Custom <see cref="IAssemblyProvider" /></param>
         public UnityContainerPopulator([NotNull] IAssemblyProvider appDomain)
         {
-            typePopulator = new TypePopulator(appDomain);
+            typePopulator     = new TypePopulator(appDomain);
             instancePopulator = new InstancePopulator(appDomain);
         }
 

src/UnityContainerAttributeRegistrationTest/Attribute/RegisterInstanceAttributeTest.cs

@@ -14,17 +14,23 @@
 
 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))]
+        [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();

src/UnityContainerAttributeRegistrationTest/Helper/TestBase.cs

@@ -16,9 +16,9 @@ protected bool IsUnityContainerRegistration(IContainerRegistration registration)
         }
 
         protected bool IsExpectedRegisteredContainer(IContainerRegistration registration,
-                                                   Type                   expectedFrom,
-                                                   Type                   expectedTo,
-                                                   Type                   expectedTypeLifetimeManagerType)
+                                                     Type                   expectedFrom,
+                                                     Type                   expectedTo,
+                                                     Type                   expectedTypeLifetimeManagerType)
         {
             bool registeredType  = registration.RegisteredType == expectedFrom;
             bool mappedToType    = registration.MappedToType == expectedTo;