Add XML docs

Author: ManticSic

src/UnityContainerAttributeRegistration/Populator/FactoryPopulator.cs

@@ -13,12 +13,17 @@
 
 namespace UnityContainerAttributeRegistration.Populator
 {
+    /// <summary>
+    ///     Populator for the <see cref="UnityContainerAttributeRegistration.Attribute.RegisterFactoryAttribute" />.
+    /// </summary>
     internal class FactoryPopulator : Populator
     {
+        /// <inheritdoc cref="Populator.Populate" />
+        /// <exception cref="InvalidOperationException">Invalid factory method.</exception>
         public override IUnityContainer Populate(IUnityContainer container, IList<Type> typesWithAttribute)
         {
             IEnumerable<FactoryToRegister> factoriesToRegister =
-                typesWithAttribute.SelectMany(providerClassType => GetInstancesToRegisterFor(container, providerClassType));
+                typesWithAttribute.SelectMany(providerClassType => GetFactoryToRegisterFor(container, providerClassType));
 
             foreach(FactoryToRegister factoryToRegister in factoriesToRegister)
             {
@@ -32,7 +37,14 @@ public override IUnityContainer Populate(IUnityContainer container, IList<Type>
             return container;
         }
 
-        private IEnumerable<FactoryToRegister> GetInstancesToRegisterFor(IUnityContainer container, Type providerClassType)
+        /// <summary>
+        ///     Get all candidates to register.
+        /// </summary>
+        /// <param name="container"><see cref="IUnityContainer" /> to instantiate the provider class</param>
+        /// <param name="providerClassType">Factory provider class</param>
+        /// <returns>List of candidates to register</returns>
+        /// <exception cref="InvalidOperationException">Invalid factory method.</exception>
+        private IEnumerable<FactoryToRegister> GetFactoryToRegisterFor(IUnityContainer container, Type providerClassType)
         {
             object       providerClassInstance = container.Resolve(providerClassType);
             MethodInfo[] methodInfos           = providerClassType.GetMethods();
@@ -43,6 +55,13 @@ private IEnumerable<FactoryToRegister> GetInstancesToRegisterFor(IUnityContainer
                   .ToList();
         }
 
+        /// <summary>
+        ///     Transform a <see cref="MethodInfo" /> and an instance to a <see cref="FactoryToRegister" /> object.
+        /// </summary>
+        /// <param name="info"><see cref="MethodInfo" /> of the factory method.</param>
+        /// <param name="instance">Instance of the factory method.</param>
+        /// <returns>Wrapper for easy registration.</returns>
+        /// <exception cref="InvalidOperationException">Invalid factory method.</exception>
         private FactoryToRegister CreateFactoryToRegisterFrom(MethodInfo info, object instance)
         {
             RegisterFactoryAttribute attribute  = info.GetCustomAttribute<RegisterFactoryAttribute>();
@@ -66,6 +85,11 @@ private FactoryToRegister CreateFactoryToRegisterFrom(MethodInfo info, object in
             return new FactoryToRegister(returnType, GetFactoryMethodFor(info, instance), lifetimeManager);
         }
 
+        /// <summary>
+        ///     Verify that the parameters matches the requirements of Unity
+        /// </summary>
+        /// <param name="methodInfo"><see cref="MethodInfo" /> to check.</param>
+        /// <returns>Whether <paramref name="methodInfo" /> matches the requirements or not.</returns>
         private bool IsUnityFactorySignature(MethodInfo methodInfo)
         {
             ParameterInfo[] parameters = methodInfo.GetParameters();
@@ -88,6 +112,12 @@ private bool IsUnityFactorySignature(MethodInfo methodInfo)
             }
         }
 
+        /// <summary>
+        ///     Create a wrapper function for a factory method.
+        /// </summary>
+        /// <param name="methodInfo"><see cref="MethodInfo" /> of the factory method.</param>
+        /// <param name="instance">Instance of the factory method.</param>
+        /// <returns><see cref="Func{TResult}" /> to call the factory method.</returns>
         private Func<IUnityContainer, Type, string, object> GetFactoryMethodFor(MethodInfo methodInfo, object instance)
         {
             return (container, typeValue, stringValue) =>
@@ -105,6 +135,9 @@ private Func<IUnityContainer, Type, string, object> GetFactoryMethodFor(MethodIn
                    };
         }
 
+        /// <summary>
+        ///     Wrapper to register factories
+        /// </summary>
         private sealed class FactoryToRegister
         {
             public FactoryToRegister([NotNull]   Type                                        returnType,
@@ -116,12 +149,21 @@ public FactoryToRegister([NotNull]   Type
                 LifetimeManager = lifetimeManager;
             }
 
+            /// <summary>
+            ///     Requested type as return type of the factory
+            /// </summary>
             [NotNull]
             public Type ReturnType { get; }
 
+            /// <summary>
+            ///     Factory method
+            /// </summary>
             [NotNull]
             public Func<IUnityContainer, Type, string, object> Factory { get; }
 
+            /// <summary>
+            ///     Used lifetime manager
+            /// </summary>
             [CanBeNull]
             public IFactoryLifetimeManager LifetimeManager { get; }
         }

src/UnityContainerAttributeRegistration/Populator/InstancePopulator.cs

@@ -18,7 +18,7 @@ namespace UnityContainerAttributeRegistration.Populator
     /// </summary>
     internal class InstancePopulator : Populator
     {
-        /// <inheritdoc cref="Populator" />
+        /// <inheritdoc cref="Populator.Populate" />
         /// <exception cref="InvalidOperationException">Class type must not be static or abstract.</exception>
         public override IUnityContainer Populate(IUnityContainer container, IList<Type> typesWithAttribute)
         {
@@ -66,7 +66,7 @@ private IEnumerable<InstanceToRegister> GetInstancesToRegisterFor(IUnityContaine
         }
 
         /// <summary>
-        ///     Wrapper to regsiter isntances
+        ///     Wrapper to register isntances
         /// </summary>
         private sealed class InstanceToRegister
         {

src/UnityContainerAttributeRegistration/Populator/TypePopulator.cs

@@ -15,7 +15,7 @@ namespace UnityContainerAttributeRegistration.Populator
     /// </summary>
     internal class TypePopulator : Populator
     {
-        /// <inheritdoc cref="Populator" />
+        /// <inheritdoc cref="Populator.Populate" />
         /// <exception cref="InvalidOperationException">Class type must not be static or abstract.</exception>
         public override IUnityContainer Populate(IUnityContainer container, IList<Type> typesWithAttribute)
         {