Code cleanup

ManticSic · ManticSic · commit 9944d0eb6507 · 2020-10-31T21:42:25.000+01:00
diff --git a/src/UnityContainerAttributeRegistration/Attribute/RegisterFactoryAttribute.cs b/src/UnityContainerAttributeRegistration/Attribute/RegisterFactoryAttribute.cs
@@ -14,7 +14,7 @@ public class RegisterFactoryAttribute : System.Attribute
         /// <summary>
         ///     Candidate for registration to <see cref="Unity" />.
         /// </summary>
-        public RegisterFactoryAttribute([CanBeNull] Type from = null,
+        public RegisterFactoryAttribute([CanBeNull] Type from            = null,
                                         [CanBeNull] Type lifetimeManager = null)
         {
             From            = from;
diff --git a/src/UnityContainerAttributeRegistration/Populator/FactoryPopulator.cs b/src/UnityContainerAttributeRegistration/Populator/FactoryPopulator.cs
@@ -22,9 +22,9 @@ public override IUnityContainer Populate(IUnityContainer container, IList<Type>
 
             foreach(FactoryToRegister factoryToRegister in factoriesToRegister)
             {
-                Type                                        returnType = factoryToRegister.ReturnType;
-                Func<IUnityContainer, Type, string, object> factory    = factoryToRegister.Factory;
-                IFactoryLifetimeManager lifetimeManager = factoryToRegister.LifetimeManager;
+                Type                                        returnType      = factoryToRegister.ReturnType;
+                Func<IUnityContainer, Type, string, object> factory         = factoryToRegister.Factory;
+                IFactoryLifetimeManager                     lifetimeManager = factoryToRegister.LifetimeManager;
 
                 container.RegisterFactory(returnType, factory, lifetimeManager);
             }
@@ -35,7 +35,7 @@ public override IUnityContainer Populate(IUnityContainer container, IList<Type>
         private IEnumerable<FactoryToRegister> GetInstancesToRegisterFor(IUnityContainer container, Type providerClassType)
         {
             object       providerClassInstance = container.Resolve(providerClassType);
-            MethodInfo[] methodInfos            = providerClassType.GetMethods();
+            MethodInfo[] methodInfos           = providerClassType.GetMethods();
 
             return methodInfos
                   .Where(info => info.CustomAttributes.Any(data => data.AttributeType == typeof(RegisterFactoryAttribute)))
@@ -63,18 +63,21 @@ private FactoryToRegister CreateFactoryToRegisterFrom(MethodInfo info, object in
                     ? null
                     : GetInstanceByType<IFactoryLifetimeManager>(attribute.LifetimeManager);
 
-
             return new FactoryToRegister(returnType, GetFactoryMethodFor(info, instance), lifetimeManager);
         }
 
         private bool IsUnityFactorySignature(MethodInfo methodInfo)
         {
-            var parameters = methodInfo.GetParameters();
+            ParameterInfo[] parameters = methodInfo.GetParameters();
 
             switch(parameters.Length)
             {
-                case 1 when parameters[0].ParameterType == typeof(IUnityContainer):
-                case 3 when parameters[0].ParameterType == typeof(IUnityContainer) && parameters[1].ParameterType == typeof(Type) && parameters[2].ParameterType == typeof(string):
+                case 1 when parameters[0]
+                               .ParameterType == typeof(IUnityContainer):
+                case 3 when parameters[0]
+                               .ParameterType == typeof(IUnityContainer) && parameters[1]
+                               .ParameterType == typeof(Type) && parameters[2]
+                               .ParameterType == typeof(string):
                 {
                     return true;
                 }
@@ -87,10 +90,12 @@ private bool IsUnityFactorySignature(MethodInfo methodInfo)
 
         private Func<IUnityContainer, Type, string, object> GetFactoryMethodFor(MethodInfo methodInfo, object instance)
         {
-            return (container, typeValue, stringValue) => {
-                       IList<object> invokeParams = new List<object>{container};
+            return (container, typeValue, stringValue) =>
+                   {
+                       IList<object> invokeParams = new List<object> {container};
 
-                       if(methodInfo.GetParameters().Length == 3)
+                       if(methodInfo.GetParameters()
+                                    .Length == 3)
                        {
                            invokeParams.Add(typeValue);
                            invokeParams.Add(stringValue);
@@ -102,10 +107,12 @@ private Func<IUnityContainer, Type, string, object> GetFactoryMethodFor(MethodIn
 
         private sealed class FactoryToRegister
         {
-            public FactoryToRegister([NotNull] Type returnType, [NotNull] Func<IUnityContainer, Type, string, object> factory, [CanBeNull] IFactoryLifetimeManager lifetimeManager)
+            public FactoryToRegister([NotNull]   Type                                        returnType,
+                                     [NotNull]   Func<IUnityContainer, Type, string, object> factory,
+                                     [CanBeNull] IFactoryLifetimeManager                     lifetimeManager)
             {
-                ReturnType           = returnType;
-                Factory              = factory;
+                ReturnType      = returnType;
+                Factory         = factory;
                 LifetimeManager = lifetimeManager;
             }
 
diff --git a/src/UnityContainerAttributeRegistration/Populator/InstancePopulator.cs b/src/UnityContainerAttributeRegistration/Populator/InstancePopulator.cs
@@ -8,7 +8,6 @@
 using Unity;
 using Unity.Lifetime;
 
-using UnityContainerAttributeRegistration.Provider;
 using UnityContainerAttributeRegistration.Attribute;
 
 
@@ -19,7 +18,7 @@ namespace UnityContainerAttributeRegistration.Populator
     /// </summary>
     internal class InstancePopulator : Populator
     {
-        /// <inheritdoc cref="Populator"/>
+        /// <inheritdoc cref="Populator" />
         /// <exception cref="InvalidOperationException">Class type must not be static or abstract.</exception>
         public override IUnityContainer Populate(IUnityContainer container, IList<Type> typesWithAttribute)
         {
diff --git a/src/UnityContainerAttributeRegistration/Populator/TypePopulator.cs b/src/UnityContainerAttributeRegistration/Populator/TypePopulator.cs
@@ -15,7 +15,7 @@ namespace UnityContainerAttributeRegistration.Populator
     /// </summary>
     internal class TypePopulator : Populator
     {
-        /// <inheritdoc cref="Populator"/>
+        /// <inheritdoc cref="Populator" />
         /// <exception cref="InvalidOperationException">Class type must not be static or abstract.</exception>
         public override IUnityContainer Populate(IUnityContainer container, IList<Type> typesWithAttribute)
         {
diff --git a/src/UnityContainerAttributeRegistration/UnityContainerPopulator.cs b/src/UnityContainerAttributeRegistration/UnityContainerPopulator.cs
@@ -23,13 +23,13 @@ public sealed class UnityContainerPopulator
         private readonly IAssemblyProvider appDomain;
 
         [NotNull]
-        private readonly IPopulator        typePopulator;
+        private readonly IPopulator typePopulator;
 
         [NotNull]
-        private readonly IPopulator        instancePopulator;
+        private readonly IPopulator instancePopulator;
 
         [NotNull]
-        private readonly IPopulator        factoryPopulator;
+        private readonly IPopulator factoryPopulator;
 
         /// <summary>
         ///     Use <see cref="System.AppDomain.CurrentDomain" /> to populate an <see cref="Unity.IUnityContainer" />
@@ -82,11 +82,11 @@ private IDictionary<Type, IList<Type>> FindAnnotatedTypes(TypeDefined typeDefine
             IEnumerable<Type> types = appDomain.GetAssemblies()
                                                .SelectMany(assembly => assembly.GetTypes());
 
-            IDictionary<Type, IList<Type>> typesPerAttribute = new Dictionary<Type, IList<Type>>()
-                                                   {
-                                                       {typeof(RegisterTypeAttribute), new List<Type>()},
-                                                       {typeof(RegisterProviderAttribute), new List<Type>()}
-                                                   };
+            IDictionary<Type, IList<Type>> typesPerAttribute = new Dictionary<Type, IList<Type>>
+                                                               {
+                                                                   {typeof(RegisterTypeAttribute), new List<Type>()},
+                                                                   {typeof(RegisterProviderAttribute), new List<Type>()}
+                                                               };
 
             foreach(Type classType in types)
             {
@@ -98,7 +98,7 @@ private IDictionary<Type, IList<Type>> FindAnnotatedTypes(TypeDefined typeDefine
                     Type        attributeType      = kv.Key;
                     IList<Type> typesWithAttribute = kv.Value;
 
-                    if (classType.IsDefined(attributeType, typeDefined == TypeDefined.Inherit))
+                    if(classType.IsDefined(attributeType, typeDefined == TypeDefined.Inherit))
                     {
                         if(classType.IsStatic() || classType.IsAbstract)
                         {
diff --git a/src/UnityContainerAttributeRegistrationTest/Assets/RegisterFactoryTestClasses/TestClasses.cs b/src/UnityContainerAttributeRegistrationTest/Assets/RegisterFactoryTestClasses/TestClasses.cs
@@ -125,7 +125,6 @@ public class ProviderWithInvalidReturnValueWithOneArgument
         public void Factory(IUnityContainer container)
         {
         }
-
     }
 
     [RegisterProvider]
@@ -135,7 +134,6 @@ public class ProviderWithInvalidReturnValueWithThreeArguments
         public void Factory(IUnityContainer container, Type typeValue, string stringValue)
         {
         }
-
     }
 
     [RegisterProvider]
@@ -146,7 +144,6 @@ public MyClass Factory(IUnityContainer container, string stringValue)
         {
             return new MyClass();
         }
-
     }
 
     [RegisterProvider]
@@ -157,7 +154,6 @@ public MyClass Factory(IUnityContainer container, Type typeValue)
         {
             return new MyClass();
         }
-
     }
 
     [RegisterProvider]
@@ -168,7 +164,6 @@ public MyClass Factory(IUnityContainer container, string stringValue, Type typeV
         {
             return new MyClass();
         }
-
     }
 
     [RegisterProvider]
@@ -179,7 +174,6 @@ public MyClass Factory(IUnityContainer container, Type typeValue, string stringV
         {
             return new MyClass();
         }
-
     }
 
     [RegisterProvider]
diff --git a/src/UnityContainerAttributeRegistrationTest/Attribute/RegisterFactoryAttributeTest.cs b/src/UnityContainerAttributeRegistrationTest/Attribute/RegisterFactoryAttributeTest.cs
@@ -23,14 +23,22 @@ public class RegisterFactoryAttributeTest : TestBase
         [TestCase(typeof(ProviderWithOneArgument), typeof(MyClass), typeof(MyClass), typeof(TransientLifetimeManager))]
         [TestCase(typeof(ProviderWithThreeArguments), typeof(MyClass), typeof(MyClass), typeof(TransientLifetimeManager))]
         [TestCase(typeof(ProviderUsingInterface), typeof(IMyInterface), typeof(IMyInterface), typeof(TransientLifetimeManager))]
-        [TestCase(typeof(ProviderWithHierarchicalLifetimeManager), typeof(MyClass), typeof(MyClass), typeof(HierarchicalLifetimeManager))]
-        [TestCase(typeof(ProviderWithSingletonLifetimeManager), typeof(MyClass), typeof(MyClass), typeof(SingletonLifetimeManager))]
-        [TestCase(typeof(ProviderWithTransientLifetimeManager), typeof(MyClass), typeof(MyClass), typeof(TransientLifetimeManager))]
-        [TestCase(typeof(ProviderWithContainerControlledLifetimeManager), typeof(MyClass), typeof(MyClass), typeof(ContainerControlledLifetimeManager))]
-        [TestCase(typeof(ProviderWithContainerControlledTransientManager), typeof(MyClass), typeof(MyClass), typeof(ContainerControlledTransientManager))]
-        [TestCase(typeof(ProviderWithExternallyControlledLifetimeManager), typeof(MyClass), typeof(MyClass), typeof(ExternallyControlledLifetimeManager))]
-        [TestCase(typeof(ProviderWithPerResolveLifetimeManager), typeof(MyClass), typeof(MyClass), typeof(PerResolveLifetimeManager))]
-        [TestCase(typeof(ProviderWithPerThreadLifetimeManager), typeof(MyClass), typeof(MyClass), typeof(PerThreadLifetimeManager))]
+        [TestCase(typeof(ProviderWithHierarchicalLifetimeManager), typeof(MyClass), typeof(MyClass),
+                  typeof(HierarchicalLifetimeManager))]
+        [TestCase(typeof(ProviderWithSingletonLifetimeManager), typeof(MyClass), typeof(MyClass),
+                  typeof(SingletonLifetimeManager))]
+        [TestCase(typeof(ProviderWithTransientLifetimeManager), typeof(MyClass), typeof(MyClass),
+                  typeof(TransientLifetimeManager))]
+        [TestCase(typeof(ProviderWithContainerControlledLifetimeManager), typeof(MyClass), typeof(MyClass),
+                  typeof(ContainerControlledLifetimeManager))]
+        [TestCase(typeof(ProviderWithContainerControlledTransientManager), typeof(MyClass), typeof(MyClass),
+                  typeof(ContainerControlledTransientManager))]
+        [TestCase(typeof(ProviderWithExternallyControlledLifetimeManager), typeof(MyClass), typeof(MyClass),
+                  typeof(ExternallyControlledLifetimeManager))]
+        [TestCase(typeof(ProviderWithPerResolveLifetimeManager), typeof(MyClass), typeof(MyClass),
+                  typeof(PerResolveLifetimeManager))]
+        [TestCase(typeof(ProviderWithPerThreadLifetimeManager), typeof(MyClass), typeof(MyClass),
+                  typeof(PerThreadLifetimeManager))]
         public void TestPopulate(Type providerType, Type expectedFrom, Type expectedTo, Type expectedFactoryLifetimeManagerType)
         {
             Scope scope = new Scope();

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public class RegisterFactoryAttribute : System.Attribute`
`14`	`14`	`/// <summary>`
`15`	`15`	`/// Candidate for registration to <see cref="Unity" />.`
`16`	`16`	`/// </summary>`
`17`		`- public RegisterFactoryAttribute([CanBeNull] Type from = null,`
	`17`	`+ public RegisterFactoryAttribute([CanBeNull] Type from = null,`
`18`	`18`	`[CanBeNull] Type lifetimeManager = null)`
`19`	`19`	`{`
`20`	`20`	`From = from;`
Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,9 @@ public override IUnityContainer Populate(IUnityContainer container, IList<Type>`
`22`	`22`
`23`	`23`	`foreach(FactoryToRegister factoryToRegister in factoriesToRegister)`
`24`	`24`	`{`
`25`		`- Type returnType = factoryToRegister.ReturnType;`
`26`		`- Func<IUnityContainer, Type, string, object> factory = factoryToRegister.Factory;`
`27`		`- IFactoryLifetimeManager lifetimeManager = factoryToRegister.LifetimeManager;`
	`25`	`+ Type returnType = factoryToRegister.ReturnType;`
	`26`	`+ Func<IUnityContainer, Type, string, object> factory = factoryToRegister.Factory;`
	`27`	`+ IFactoryLifetimeManager lifetimeManager = factoryToRegister.LifetimeManager;`
`28`	`28`
`29`	`29`	`container.RegisterFactory(returnType, factory, lifetimeManager);`
`30`	`30`	`}`
`@@ -35,7 +35,7 @@ public override IUnityContainer Populate(IUnityContainer container, IList<Type>`
`35`	`35`	`private IEnumerable<FactoryToRegister> GetInstancesToRegisterFor(IUnityContainer container, Type providerClassType)`
`36`	`36`	`{`
`37`	`37`	`object providerClassInstance = container.Resolve(providerClassType);`
`38`		`- MethodInfo[] methodInfos = providerClassType.GetMethods();`
	`38`	`+ MethodInfo[] methodInfos = providerClassType.GetMethods();`
`39`	`39`
`40`	`40`	`return methodInfos`
`41`	`41`	`.Where(info => info.CustomAttributes.Any(data => data.AttributeType == typeof(RegisterFactoryAttribute)))`
`@@ -63,18 +63,21 @@ private FactoryToRegister CreateFactoryToRegisterFrom(MethodInfo info, object in`
`63`	`63`	`? null`
`64`	`64`	`: GetInstanceByType<IFactoryLifetimeManager>(attribute.LifetimeManager);`
`65`	`65`
`66`		`-`
`67`	`66`	`return new FactoryToRegister(returnType, GetFactoryMethodFor(info, instance), lifetimeManager);`
`68`	`67`	`}`
`69`	`68`
`70`	`69`	`private bool IsUnityFactorySignature(MethodInfo methodInfo)`
`71`	`70`	`{`
`72`		`- var parameters = methodInfo.GetParameters();`
	`71`	`+ ParameterInfo[] parameters = methodInfo.GetParameters();`
`73`	`72`
`74`	`73`	`switch(parameters.Length)`
`75`	`74`	`{`
`76`		`- case 1 when parameters[0].ParameterType == typeof(IUnityContainer):`
`77`		`- case 3 when parameters[0].ParameterType == typeof(IUnityContainer) && parameters[1].ParameterType == typeof(Type) && parameters[2].ParameterType == typeof(string):`
	`75`	`+ case 1 when parameters[0]`
	`76`	`+ .ParameterType == typeof(IUnityContainer):`
	`77`	`+ case 3 when parameters[0]`
	`78`	`+ .ParameterType == typeof(IUnityContainer) && parameters[1]`
	`79`	`+ .ParameterType == typeof(Type) && parameters[2]`
	`80`	`+ .ParameterType == typeof(string):`
`78`	`81`	`{`
`79`	`82`	`return true;`
`80`	`83`	`}`
`@@ -87,10 +90,12 @@ private bool IsUnityFactorySignature(MethodInfo methodInfo)`
`87`	`90`
`88`	`91`	`private Func<IUnityContainer, Type, string, object> GetFactoryMethodFor(MethodInfo methodInfo, object instance)`
`89`	`92`	`{`
`90`		`- return (container, typeValue, stringValue) => {`
`91`		`- IList<object> invokeParams = new List<object>{container};`
	`93`	`+ return (container, typeValue, stringValue) =>`
	`94`	`+ {`
	`95`	`+ IList<object> invokeParams = new List<object> {container};`
`92`	`96`
`93`		`- if(methodInfo.GetParameters().Length == 3)`
	`97`	`+ if(methodInfo.GetParameters()`
	`98`	`+ .Length == 3)`
`94`	`99`	`{`
`95`	`100`	`invokeParams.Add(typeValue);`
`96`	`101`	`invokeParams.Add(stringValue);`
`@@ -102,10 +107,12 @@ private Func<IUnityContainer, Type, string, object> GetFactoryMethodFor(MethodIn`
`102`	`107`
`103`	`108`	`private sealed class FactoryToRegister`
`104`	`109`	`{`
`105`		`- public FactoryToRegister([NotNull] Type returnType, [NotNull] Func<IUnityContainer, Type, string, object> factory, [CanBeNull] IFactoryLifetimeManager lifetimeManager)`
	`110`	`+ public FactoryToRegister([NotNull] Type returnType,`
	`111`	`+ [NotNull] Func<IUnityContainer, Type, string, object> factory,`
	`112`	`+ [CanBeNull] IFactoryLifetimeManager lifetimeManager)`
`106`	`113`	`{`
`107`		`- ReturnType = returnType;`
`108`		`- Factory = factory;`
	`114`	`+ ReturnType = returnType;`
	`115`	`+ Factory = factory;`
`109`	`116`	`LifetimeManager = lifetimeManager;`
`110`	`117`	`}`
`111`	`118`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@`
`8`	`8`	`using Unity;`
`9`	`9`	`using Unity.Lifetime;`
`10`	`10`
`11`		`-using UnityContainerAttributeRegistration.Provider;`
`12`	`11`	`using UnityContainerAttributeRegistration.Attribute;`
`13`	`12`
`14`	`13`
`@@ -19,7 +18,7 @@ namespace UnityContainerAttributeRegistration.Populator`
`19`	`18`	`/// </summary>`
`20`	`19`	`internal class InstancePopulator : Populator`
`21`	`20`	`{`
`22`		`- /// <inheritdoc cref="Populator"/>`
	`21`	`+ /// <inheritdoc cref="Populator" />`
`23`	`22`	`/// <exception cref="InvalidOperationException">Class type must not be static or abstract.</exception>`
`24`	`23`	`public override IUnityContainer Populate(IUnityContainer container, IList<Type> typesWithAttribute)`
`25`	`24`	`{`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ namespace UnityContainerAttributeRegistration.Populator`
`15`	`15`	`/// </summary>`
`16`	`16`	`internal class TypePopulator : Populator`
`17`	`17`	`{`
`18`		`- /// <inheritdoc cref="Populator"/>`
	`18`	`+ /// <inheritdoc cref="Populator" />`
`19`	`19`	`/// <exception cref="InvalidOperationException">Class type must not be static or abstract.</exception>`
`20`	`20`	`public override IUnityContainer Populate(IUnityContainer container, IList<Type> typesWithAttribute)`
`21`	`21`	`{`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,6 @@ public class ProviderWithInvalidReturnValueWithOneArgument`
`125`	`125`	`public void Factory(IUnityContainer container)`
`126`	`126`	`{`
`127`	`127`	`}`
`128`		`-`
`129`	`128`	`}`
`130`	`129`
`131`	`130`	`[RegisterProvider]`
`@@ -135,7 +134,6 @@ public class ProviderWithInvalidReturnValueWithThreeArguments`
`135`	`134`	`public void Factory(IUnityContainer container, Type typeValue, string stringValue)`
`136`	`135`	`{`
`137`	`136`	`}`
`138`		`-`
`139`	`137`	`}`
`140`	`138`
`141`	`139`	`[RegisterProvider]`
`@@ -146,7 +144,6 @@ public MyClass Factory(IUnityContainer container, string stringValue)`
`146`	`144`	`{`
`147`	`145`	`return new MyClass();`
`148`	`146`	`}`
`149`		`-`
`150`	`147`	`}`
`151`	`148`
`152`	`149`	`[RegisterProvider]`
`@@ -157,7 +154,6 @@ public MyClass Factory(IUnityContainer container, Type typeValue)`
`157`	`154`	`{`
`158`	`155`	`return new MyClass();`
`159`	`156`	`}`
`160`		`-`
`161`	`157`	`}`
`162`	`158`
`163`	`159`	`[RegisterProvider]`
`@@ -168,7 +164,6 @@ public MyClass Factory(IUnityContainer container, string stringValue, Type typeV`
`168`	`164`	`{`
`169`	`165`	`return new MyClass();`
`170`	`166`	`}`
`171`		`-`
`172`	`167`	`}`
`173`	`168`
`174`	`169`	`[RegisterProvider]`
`@@ -179,7 +174,6 @@ public MyClass Factory(IUnityContainer container, Type typeValue, string stringV`
`179`	`174`	`{`
`180`	`175`	`return new MyClass();`
`181`	`176`	`}`
`182`		`-`
`183`	`177`	`}`
`184`	`178`
`185`	`179`	`[RegisterProvider]`