- use file scoped namespaces

LightweightIocContainer/ActionExtension.cs

@@ -4,23 +4,22 @@
 
 using System;
 
-namespace LightweightIocContainer
+namespace LightweightIocContainer;
+
+internal static class ActionExtension
 {
-    internal static class ActionExtension
+    /// <summary>
+    /// Convert an <see cref="Action{T2}"/> to an <see cref="Action{T1}"/> of an inherited <see cref="Type"/>
+    /// </summary>
+    /// <typeparam name="T1">The <see cref="Type"/> of the <see cref="Action{T1}"/> to convert to, has to be implemented by <typeparamref name="T2"/></typeparam>
+    /// <typeparam name="T2">The <see cref="Type"/> of the given <see cref="Action{T2}"/>, has to implement <typeparamref name="T1"/></typeparam>
+    /// <param name="action">The given <see cref="Action{T2}"/> to convert</param>
+    /// <returns>An <see cref="Action{T1}"/> converted from the given <see cref="Action{T2}"/></returns>
+    public static Action<T1>? Convert<T1, T2>(this Action<T2>? action) where T1 : T2
     {
-        /// <summary>
+        if (action == null)
-        /// Convert an <see cref="Action{T2}"/> to an <see cref="Action{T1}"/> of an inherited <see cref="Type"/>
+            return null;
-        /// </summary>
-        /// <typeparam name="T1">The <see cref="Type"/> of the <see cref="Action{T1}"/> to convert to, has to be implemented by <typeparamref name="T2"/></typeparam>
-        /// <typeparam name="T2">The <see cref="Type"/> of the given <see cref="Action{T2}"/>, has to implement <typeparamref name="T1"/></typeparam>
-        /// <param name="action">The given <see cref="Action{T2}"/> to convert</param>
-        /// <returns>An <see cref="Action{T1}"/> converted from the given <see cref="Action{T2}"/></returns>
-        public static Action<T1>? Convert<T1, T2>(this Action<T2>? action) where T1 : T2
-        {
-            if (action == null)
-                return null;
 
-            return t => action(t);
+        return t => action(t);
-        }
     }
 }

LightweightIocContainer/EnumerableExtension.cs

@@ -6,61 +6,60 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 
-namespace LightweightIocContainer
+namespace LightweightIocContainer;
+
+internal static class EnumerableExtension
 {
-    internal static class EnumerableExtension
+    /// <summary>
-    {
+    /// Returns the first element of a <see cref="IEnumerable{T}"/>, or a new instance of a given <see cref="Type"/> if the <see cref="IEnumerable{T}"/> contains no elements
-        /// <summary>
+    /// </summary>
-        /// Returns the first element of a <see cref="IEnumerable{T}"/>, or a new instance of a given <see cref="Type"/> if the <see cref="IEnumerable{T}"/> contains no elements
+    /// <typeparam name="TSource">The source <see cref="Type"/> of the <see cref="IEnumerable{T}"/></typeparam>
-        /// </summary>
+    /// <typeparam name="TGiven">The given <see cref="Type"/> to return if the <see cref="IEnumerable{T}"/> contains no elements</typeparam>
-        /// <typeparam name="TSource">The source <see cref="Type"/> of the <see cref="IEnumerable{T}"/></typeparam>
+    /// <param name="source">The given <see cref="IEnumerable{T}"/></param>
-        /// <typeparam name="TGiven">The given <see cref="Type"/> to return if the <see cref="IEnumerable{T}"/> contains no elements</typeparam>
+    /// <returns>The first element of the <see cref="IEnumerable{T}"/>, or a new instance of a given <see cref="Type"/> if the <see cref="IEnumerable{T}"/> contains no elements</returns>
-        /// <param name="source">The given <see cref="IEnumerable{T}"/></param>
+    public static TSource FirstOrGiven<TSource, TGiven>(this IEnumerable<TSource> source) where TGiven : TSource, new() =>
-        /// <returns>The first element of the <see cref="IEnumerable{T}"/>, or a new instance of a given <see cref="Type"/> if the <see cref="IEnumerable{T}"/> contains no elements</returns>
+        source.TryGetFirst<TSource, TGiven>(null);
-        public static TSource FirstOrGiven<TSource, TGiven>(this IEnumerable<TSource> source) where TGiven : TSource, new() =>
-            source.TryGetFirst<TSource, TGiven>(null);
 
-        /// <summary>
+    /// <summary>
-        /// Returns the first element of a <see cref="IEnumerable{T}"/> that satisfies a condition, or a new instance of a given <see cref="Type"/> if no such element is found
+    /// Returns the first element of a <see cref="IEnumerable{T}"/> that satisfies a condition, or a new instance of a given <see cref="Type"/> if no such element is found
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TSource">The source <see cref="Type"/> of the <see cref="IEnumerable{T}"/></typeparam>
+    /// <typeparam name="TSource">The source <see cref="Type"/> of the <see cref="IEnumerable{T}"/></typeparam>
-        /// <typeparam name="TGiven">The given <see cref="Type"/> to return if the <see cref="IEnumerable{T}"/> contains no element that satisfies the given condition</typeparam>
+    /// <typeparam name="TGiven">The given <see cref="Type"/> to return if the <see cref="IEnumerable{T}"/> contains no element that satisfies the given condition</typeparam>
-        /// <param name="source">The given <see cref="IEnumerable{T}"/></param>
+    /// <param name="source">The given <see cref="IEnumerable{T}"/></param>
-        /// <param name="predicate">A function to test each element for a condition</param>
+    /// <param name="predicate">A function to test each element for a condition</param>
-        /// <returns>The first element of the <see cref="IEnumerable{T}"/> that satisfies a condition, or a new instance of the given <see cref="Type"/> if no such element is found</returns>
+    /// <returns>The first element of the <see cref="IEnumerable{T}"/> that satisfies a condition, or a new instance of the given <see cref="Type"/> if no such element is found</returns>
-        public static TSource FirstOrGiven<TSource, TGiven>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) where TGiven : TSource, new() =>
+    public static TSource FirstOrGiven<TSource, TGiven>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) where TGiven : TSource, new() =>
-            source.TryGetFirst<TSource, TGiven>(predicate);
+        source.TryGetFirst<TSource, TGiven>(predicate);
 
-        /// <summary>
+    /// <summary>
-        /// Tries to get the first element of the given <see cref="IEnumerable{T}"/> or creates a new element of a given <see cref="Type"/> when no element is found
+    /// Tries to get the first element of the given <see cref="IEnumerable{T}"/> or creates a new element of a given <see cref="Type"/> when no element is found
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TSource">The source <see cref="Type"/> of the <see cref="IEnumerable{T}"/></typeparam>
+    /// <typeparam name="TSource">The source <see cref="Type"/> of the <see cref="IEnumerable{T}"/></typeparam>
-        /// <typeparam name="TGiven">The given <see cref="Type"/> to create a new element when no fitting element is found</typeparam>
+    /// <typeparam name="TGiven">The given <see cref="Type"/> to create a new element when no fitting element is found</typeparam>
-        /// <param name="source">The given <see cref="IEnumerable{T}"/></param>
+    /// <param name="source">The given <see cref="IEnumerable{T}"/></param>
-        /// <param name="predicate">A function to test each element for a condition</param>
+    /// <param name="predicate">A function to test each element for a condition</param>
-        /// <returns>The first element of the <see cref="IEnumerable{T}"/> or a new instance of the given <see cref="Type"/> when no element is found</returns>
+    /// <returns>The first element of the <see cref="IEnumerable{T}"/> or a new instance of the given <see cref="Type"/> when no element is found</returns>
-        private static TSource TryGetFirst<TSource, TGiven>(this IEnumerable<TSource> source, Func<TSource, bool>? predicate) where TGiven : TSource, new()
+    private static TSource TryGetFirst<TSource, TGiven>(this IEnumerable<TSource> source, Func<TSource, bool>? predicate) where TGiven : TSource, new()
+    {
+        try
         {
-            try
+            return predicate == null ? source.First() : source.First(predicate);
-            {
-                return predicate == null ? source.First() : source.First(predicate);
-            }
-            catch (Exception)
-            {
-                return new TGiven();
-            }
         }
-
+        catch (Exception)
-        /// <summary>
-        /// Executes an <see cref="Action{T}"/> for each item in an <see cref="IEnumerable{T}"/>
-        /// </summary>
-        /// <param name="enumerable">The <see cref="IEnumerable{T}"/></param>
-        /// <param name="action">The <see cref="Action{T}"/></param>
-        /// <typeparam name="T">The <see cref="Type"/> of the items in the <see cref="IEnumerable{T}"/></typeparam>
-        public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
         {
-            foreach (T item in enumerable) 
+            return new TGiven();
-                action(item);
         }
     }
+
+    /// <summary>
+    /// Executes an <see cref="Action{T}"/> for each item in an <see cref="IEnumerable{T}"/>
+    /// </summary>
+    /// <param name="enumerable">The <see cref="IEnumerable{T}"/></param>
+    /// <param name="action">The <see cref="Action{T}"/></param>
+    /// <typeparam name="T">The <see cref="Type"/> of the items in the <see cref="IEnumerable{T}"/></typeparam>
+    public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
+    {
+        foreach (T item in enumerable) 
+            action(item);
+    }
 }

LightweightIocContainer/Exceptions/CircularDependencyException.cs

@@ -7,55 +7,54 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// A circular dependency was detected during <see cref="IocContainer.Resolve{T}()"/>
+/// </summary>
+internal class CircularDependencyException : IocContainerException
 {
     /// <summary>
     /// A circular dependency was detected during <see cref="IocContainer.Resolve{T}()"/>
     /// </summary>
-    internal class CircularDependencyException : IocContainerException
+    /// <param name="resolvingType">The currently resolving <see cref="Type"/></param>
+    /// <param name="resolveStack">The resolve stack at the time the <see cref="CircularDependencyException"/> was thrown</param>
+    public CircularDependencyException(Type resolvingType, List<Type> resolveStack)
     {
-        /// <summary>
+        ResolvingType = resolvingType;
-        /// A circular dependency was detected during <see cref="IocContainer.Resolve{T}()"/>
+        ResolveStack = resolveStack;
-        /// </summary>
+    }
-        /// <param name="resolvingType">The currently resolving <see cref="Type"/></param>
-        /// <param name="resolveStack">The resolve stack at the time the <see cref="CircularDependencyException"/> was thrown</param>
-        public CircularDependencyException(Type resolvingType, List<Type> resolveStack)
-        {
-            ResolvingType = resolvingType;
-            ResolveStack = resolveStack;
-        }
 
 
-        /// <summary>
+    /// <summary>
-        /// The currently resolving <see cref="Type"/>
+    /// The currently resolving <see cref="Type"/>
-        /// </summary>
+    /// </summary>
-        public Type ResolvingType { get; }
+    public Type ResolvingType { get; }
 
-        /// <summary>
+    /// <summary>
-        /// The resolve stack at the time the <see cref="CircularDependencyException"/> was thrown
+    /// The resolve stack at the time the <see cref="CircularDependencyException"/> was thrown
-        /// </summary>
+    /// </summary>
-        public List<Type> ResolveStack { get; }
+    public List<Type> ResolveStack { get; }
 
-        /// <summary>
+    /// <summary>
-        /// The exception message
+    /// The exception message
-        /// </summary>
+    /// </summary>
-        public override string Message
+    public override string Message
+    {
+        get
         {
-            get
+            StringBuilder message = new($"Circular dependency has been detected when trying to resolve `{ResolvingType}`.\n");
-            {
+            if (!ResolveStack.Any())
-                StringBuilder message = new($"Circular dependency has been detected when trying to resolve `{ResolvingType}`.\n");
+                return message.ToString();
-                if (!ResolveStack.Any())
-                    return message.ToString();
 
-                message.Append("Resolve stack that resulted in the circular dependency:\n");
+            message.Append("Resolve stack that resulted in the circular dependency:\n");
-                message.Append($"\t`{ResolvingType}` resolved as dependency of\n");
+            message.Append($"\t`{ResolvingType}` resolved as dependency of\n");
 
-                for (int i = ResolveStack.Count - 1; i >= 1 ; i--)
+            for (int i = ResolveStack.Count - 1; i >= 1 ; i--)
-                    message.Append($"\t`{ResolveStack[i]}` resolved as dependency of\n");
+                message.Append($"\t`{ResolveStack[i]}` resolved as dependency of\n");
 
-                message.Append($"\t`{ResolveStack[0]}` which is the root type being resolved.");
+            message.Append($"\t`{ResolveStack[0]}` which is the root type being resolved.");
-                return message.ToString();
+            return message.ToString();
-            }
         }
     }
 }

LightweightIocContainer/Exceptions/ConstructorNotMatchingException.cs

@@ -5,25 +5,24 @@
 using System;
 using System.Reflection;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// The constructor does not match the given or resolvable arguments
+/// </summary>
+internal class ConstructorNotMatchingException : IocContainerException
 {
     /// <summary>
     /// The constructor does not match the given or resolvable arguments
     /// </summary>
-    internal class ConstructorNotMatchingException : IocContainerException
+    /// <param name="constructor">The constructor that does not match</param>
-    {
+    /// <param name="exception">The inner exception</param>
-        /// <summary>
+    public ConstructorNotMatchingException(ConstructorInfo constructor, Exception exception)
-        /// The constructor does not match the given or resolvable arguments
+        : base($"Constructor {constructor} does not match the given or resolvable arguments.", exception) =>
-        /// </summary>
+        Constructor = constructor;
-        /// <param name="constructor">The constructor that does not match</param>
-        /// <param name="exception">The inner exception</param>
-        public ConstructorNotMatchingException(ConstructorInfo constructor, Exception exception)
-            : base($"Constructor {constructor} does not match the given or resolvable arguments.", exception) =>
-            Constructor = constructor;
 
-        /// <summary>
+    /// <summary>
-        /// The constructor that does not match
+    /// The constructor that does not match
-        /// </summary>
+    /// </summary>
-        public ConstructorInfo Constructor { get; }
+    public ConstructorInfo Constructor { get; }
-    }
 }

LightweightIocContainer/Exceptions/GenericMethodNotFoundException.cs

@@ -4,21 +4,20 @@
 
 using System;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// Could not find generic method
+/// </summary>
+internal class GenericMethodNotFoundException : Exception
 {
     /// <summary>
     /// Could not find generic method
     /// </summary>
-    internal class GenericMethodNotFoundException : Exception
+    /// <param name="functionName">The name of the generic method</param>
+    public GenericMethodNotFoundException(string functionName)
+        : base($"Could not find function {functionName}")
     {
-        /// <summary>
-        /// Could not find generic method
-        /// </summary>
-        /// <param name="functionName">The name of the generic method</param>
-        public GenericMethodNotFoundException(string functionName)
-            : base($"Could not find function {functionName}")
-        {
             
-        }
     }
 }

LightweightIocContainer/Exceptions/IllegalAbstractMethodCreationException.cs

@@ -4,25 +4,24 @@
 
 using System.Reflection;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// The creation of the abstract method is illegal in its current state
+/// </summary>
+internal class IllegalAbstractMethodCreationException : IocContainerException
 {
     /// <summary>
     /// The creation of the abstract method is illegal in its current state
     /// </summary>
-    internal class IllegalAbstractMethodCreationException : IocContainerException
+    /// <param name="message">The exception message</param>
-    {
+    /// <param name="method">The method that is illegal to create</param>
-        /// <summary>
+    public IllegalAbstractMethodCreationException(string message, MethodInfo method)
-        /// The creation of the abstract method is illegal in its current state
+        : base(message) =>
-        /// </summary>
+        Method = method;
-        /// <param name="message">The exception message</param>
-        /// <param name="method">The method that is illegal to create</param>
-        public IllegalAbstractMethodCreationException(string message, MethodInfo method)
-            : base(message) =>
-            Method = method;
 
-        /// <summary>
+    /// <summary>
-        /// The Method whose creation is illegal
+    /// The Method whose creation is illegal
-        /// </summary>
+    /// </summary>
-        public MethodInfo Method { get; }
+    public MethodInfo Method { get; }
-    }
 }

LightweightIocContainer/Exceptions/InternalResolveException.cs

@@ -4,21 +4,20 @@
 
 using LightweightIocContainer.Interfaces;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// An internal Error happened while the <see cref="IIocContainer"/> tried to resolve an instance
+/// </summary>
+internal class InternalResolveException : IocContainerException
 {
     /// <summary>
     /// An internal Error happened while the <see cref="IIocContainer"/> tried to resolve an instance
     /// </summary>
-    internal class InternalResolveException : IocContainerException
+    /// <param name="message">The exception message</param>
+    public InternalResolveException(string message)
+        : base(message)
     {
-        /// <summary>
-        /// An internal Error happened while the <see cref="IIocContainer"/> tried to resolve an instance
-        /// </summary>
-        /// <param name="message">The exception message</param>
-        public InternalResolveException(string message)
-            : base(message)
-        {
 
-        }
     }
 }

LightweightIocContainer/Exceptions/InvalidFactoryRegistrationException.cs

@@ -2,21 +2,20 @@
 // Created: 2019-05-20
 // Copyright(c) 2019 SimonG. All Rights Reserved.
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// The registration of a Factory is not valid
+/// </summary>
+internal class InvalidFactoryRegistrationException : InvalidRegistrationException
 {
     /// <summary>
     /// The registration of a Factory is not valid
     /// </summary>
-    internal class InvalidFactoryRegistrationException : InvalidRegistrationException
+    /// <param name="message">The exception message</param>
+    public InvalidFactoryRegistrationException(string message)
+        : base(message)
     {
-        /// <summary>
-        /// The registration of a Factory is not valid
-        /// </summary>
-        /// <param name="message">The exception message</param>
-        public InvalidFactoryRegistrationException(string message)
-            : base(message)
-        {
 
-        }
     }
 }

LightweightIocContainer/Exceptions/InvalidRegistrationException.cs

@@ -2,21 +2,20 @@
 // Created: 2019-05-20
 // Copyright(c) 2019 SimonG. All Rights Reserved.
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// The registration is not valid
+/// </summary>
+internal class InvalidRegistrationException : IocContainerException
 {
     /// <summary>
     /// The registration is not valid
     /// </summary>
-    internal class InvalidRegistrationException : IocContainerException
+    /// <param name="message">The exception message</param>
+    public InvalidRegistrationException(string message)
+        : base(message)
     {
-        /// <summary>
-        /// The registration is not valid
-        /// </summary>
-        /// <param name="message">The exception message</param>
-        public InvalidRegistrationException(string message)
-            : base(message)
-        {
 
-        }
     }
 }

LightweightIocContainer/Exceptions/IocContainerException.cs

@@ -5,38 +5,37 @@
 using System;
 using System.Collections.Generic;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// A base <see cref="Exception"/> for the <see cref="LightweightIocContainer"/>
+/// </summary>
+public abstract class IocContainerException : Exception
 {
     /// <summary>
     /// A base <see cref="Exception"/> for the <see cref="LightweightIocContainer"/>
     /// </summary>
-    public abstract class IocContainerException : Exception
+    protected IocContainerException() => InnerExceptions = new List<Exception>();
-    {
-        /// <summary>
-        /// A base <see cref="Exception"/> for the <see cref="LightweightIocContainer"/>
-        /// </summary>
-        protected IocContainerException() => InnerExceptions = new List<Exception>();
 
-        /// <summary>
+    /// <summary>
-        /// A base <see cref="Exception"/> for the <see cref="LightweightIocContainer"/>
+    /// A base <see cref="Exception"/> for the <see cref="LightweightIocContainer"/>
-        /// </summary>
+    /// </summary>
-        /// <param name="message">The message of the <see cref="Exception"/></param>
+    /// <param name="message">The message of the <see cref="Exception"/></param>
-        protected IocContainerException(string message)
+    protected IocContainerException(string message)
-            : base(message) =>
+        : base(message) =>
-            InnerExceptions = new List<Exception>();
+        InnerExceptions = new List<Exception>();
 
-        /// <summary>
+    /// <summary>
-        /// A base <see cref="Exception"/> for the <see cref="LightweightIocContainer"/>
+    /// A base <see cref="Exception"/> for the <see cref="LightweightIocContainer"/>
-        /// </summary>
+    /// </summary>
-        /// <param name="message">The message of the <see cref="Exception"/></param>
+    /// <param name="message">The message of the <see cref="Exception"/></param>
-        /// <param name="innerException">The inner <see cref="Exception"/></param>
+    /// <param name="innerException">The inner <see cref="Exception"/></param>
-        protected IocContainerException(string message, Exception innerException)
+    protected IocContainerException(string message, Exception innerException)
-            : base(message, innerException) =>
+        : base(message, innerException) =>
-            InnerExceptions = new List<Exception> {innerException};
+        InnerExceptions = new List<Exception> {innerException};
 
-        /// <summary>
+    /// <summary>
-        /// The inner exceptions of the <see cref="IocContainerException"/>
+    /// The inner exceptions of the <see cref="IocContainerException"/>
-        /// </summary>
+    /// </summary>
-        public List<Exception> InnerExceptions { get; protected init; }
+    public List<Exception> InnerExceptions { get; protected init; }
-    }
 }

LightweightIocContainer/Exceptions/MultipleRegistrationException.cs

@@ -5,24 +5,23 @@
 using System;
 using LightweightIocContainer.Interfaces;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// The <see cref="System.Type"/> is already registered differently in this <see cref="IIocContainer"/>
+/// </summary>
+internal class MultipleRegistrationException : IocContainerException
 {
     /// <summary>
     /// The <see cref="System.Type"/> is already registered differently in this <see cref="IIocContainer"/>
     /// </summary>
-    internal class MultipleRegistrationException : IocContainerException
+    /// <param name="type">The <see cref="System.Type"/> that is already registered in this <see cref="IIocContainer"/></param>
-    {
+    public MultipleRegistrationException(Type type)
-        /// <summary>
+        : base($"Type {type.Name} is already registered differently in this IocContainer.") =>
-        /// The <see cref="System.Type"/> is already registered differently in this <see cref="IIocContainer"/>
+        Type = type;
-        /// </summary>
-        /// <param name="type">The <see cref="System.Type"/> that is already registered in this <see cref="IIocContainer"/></param>
-        public MultipleRegistrationException(Type type)
-            : base($"Type {type.Name} is already registered differently in this IocContainer.") =>
-            Type = type;
 
-        /// <summary>
+    /// <summary>
-        /// The registered <see cref="System.Type"/>
+    /// The registered <see cref="System.Type"/>
-        /// </summary>
+    /// </summary>
-        public Type Type { get; }
+    public Type Type { get; }
-    }
 }

LightweightIocContainer/Exceptions/MultitonResolveException.cs

@@ -4,25 +4,24 @@
 
 using System;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// An error happened while trying to resolve a multiton
+/// </summary>
+internal class MultitonResolveException : InternalResolveException
 {
     /// <summary>
     /// An error happened while trying to resolve a multiton
     /// </summary>
-    internal class MultitonResolveException : InternalResolveException
+    /// <param name="message">The exception message</param>
-    {
+    /// <param name="type">The <see cref="System.Type"/> of the multiton that's responsible for the exception</param>
-        /// <summary>
+    public MultitonResolveException(string message, Type type)
-        /// An error happened while trying to resolve a multiton
+        : base(message) =>
-        /// </summary>
+        Type = type;
-        /// <param name="message">The exception message</param>
-        /// <param name="type">The <see cref="System.Type"/> of the multiton that's responsible for the exception</param>
-        public MultitonResolveException(string message, Type type)
-            : base(message) =>
-            Type = type;
 
-        /// <summary>
+    /// <summary>
-        /// The <see cref="System.Type"/> of the multiton that's responsible for the exception
+    /// The <see cref="System.Type"/> of the multiton that's responsible for the exception
-        /// </summary>
+    /// </summary>
-        public Type Type { get; }
+    public Type Type { get; }
-    }
 }

LightweightIocContainer/Exceptions/NoMatchingConstructorFoundException.cs

@@ -5,34 +5,33 @@
 using System;
 using System.Collections.Generic;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// No matching constructor was found for the given or resolvable arguments
+/// </summary>
+internal class NoMatchingConstructorFoundException : IocContainerException
 {
     /// <summary>
     /// No matching constructor was found for the given or resolvable arguments
     /// </summary>
-    internal class NoMatchingConstructorFoundException : IocContainerException
+    /// <param name="type">The <see cref="Type"/> with no matching constructor</param>
+    public NoMatchingConstructorFoundException(Type type)
+        : base($"No matching constructor for {type} found.")
     {
-        /// <summary>
+        Type = type;
-        /// No matching constructor was found for the given or resolvable arguments
+        InnerExceptions = new List<Exception>();
-        /// </summary>
+    }
-        /// <param name="type">The <see cref="Type"/> with no matching constructor</param>
-        public NoMatchingConstructorFoundException(Type type)
-            : base($"No matching constructor for {type} found.")
-        {
-            Type = type;
-            InnerExceptions = new List<Exception>();
-        }
 
 
-        /// <summary>
+    /// <summary>
-        /// The <see cref="Type"/> with no matching constructor
+    /// The <see cref="Type"/> with no matching constructor
-        /// </summary>
+    /// </summary>
-        public Type Type { get; }
+    public Type Type { get; }
 
-        /// <summary>
+    /// <summary>
-        /// Add an inner exception to the <see cref="IocContainerException.InnerExceptions"/>
+    /// Add an inner exception to the <see cref="IocContainerException.InnerExceptions"/>
-        /// </summary>
+    /// </summary>
-        /// <param name="exception">The <see cref="ConstructorNotMatchingException"/></param>
+    /// <param name="exception">The <see cref="ConstructorNotMatchingException"/></param>
-        public void AddInnerException(ConstructorNotMatchingException exception) => InnerExceptions.Add(exception);
+    public void AddInnerException(ConstructorNotMatchingException exception) => InnerExceptions.Add(exception);
-    }
 }

LightweightIocContainer/Exceptions/NoPublicConstructorFoundException.cs

@@ -4,24 +4,23 @@
 
 using System;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// No public constructor can be found for a <see cref="Type"/>
+/// </summary>
+internal class NoPublicConstructorFoundException : IocContainerException
 {
     /// <summary>
     /// No public constructor can be found for a <see cref="Type"/>
     /// </summary>
-    internal class NoPublicConstructorFoundException : IocContainerException
+    /// <param name="type">The <see cref="Type"/> with no public constructor</param>
-    {
+    public NoPublicConstructorFoundException(Type type)
-        /// <summary>
+        : base($"No public constructor for {type} found.") =>
-        /// No public constructor can be found for a <see cref="Type"/>
+        Type = type;
-        /// </summary>
-        /// <param name="type">The <see cref="Type"/> with no public constructor</param>
-        public NoPublicConstructorFoundException(Type type)
-            : base($"No public constructor for {type} found.") =>
-            Type = type;
 
-        /// <summary>
+    /// <summary>
-        /// The <see cref="Type"/> with no public constructor
+    /// The <see cref="Type"/> with no public constructor
-        /// </summary>
+    /// </summary>
-        public Type Type { get; }
+    public Type Type { get; }
-    }
 }

LightweightIocContainer/Exceptions/TypeNotRegisteredException.cs

@@ -5,24 +5,23 @@
 using System;
 using LightweightIocContainer.Interfaces;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// The <see cref="System.Type"/> is not registered in this <see cref="IIocContainer"/>
+/// </summary>
+internal class TypeNotRegisteredException : IocContainerException
 {
     /// <summary>
     /// The <see cref="System.Type"/> is not registered in this <see cref="IIocContainer"/>
     /// </summary>
-    internal class TypeNotRegisteredException : IocContainerException
+    /// <param name="type">The unregistered <see cref="System.Type"/></param>
-    {
+    public TypeNotRegisteredException(Type type)
-        /// <summary>
+        : base($"Type {type.Name} is not registered in this IocContainer.") =>
-        /// The <see cref="System.Type"/> is not registered in this <see cref="IIocContainer"/>
+        Type = type;
-        /// </summary>
-        /// <param name="type">The unregistered <see cref="System.Type"/></param>
-        public TypeNotRegisteredException(Type type)
-            : base($"Type {type.Name} is not registered in this IocContainer.") =>
-            Type = type;
 
-        /// <summary>
+    /// <summary>
-        /// The unregistered <see cref="System.Type"/>
+    /// The unregistered <see cref="System.Type"/>
-        /// </summary>
+    /// </summary>
-        public Type Type { get; }
+    public Type Type { get; }
-    }
 }

LightweightIocContainer/Exceptions/UnknownRegistrationException.cs

@@ -4,21 +4,20 @@
 
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Exceptions
+namespace LightweightIocContainer.Exceptions;
+
+/// <summary>
+/// An unknown <see cref="IRegistration"/> was used
+/// </summary>
+internal class UnknownRegistrationException : IocContainerException
 {
     /// <summary>
     /// An unknown <see cref="IRegistration"/> was used
     /// </summary>
-    internal class UnknownRegistrationException : IocContainerException
+    /// <param name="message">The exception message</param>
+    public UnknownRegistrationException(string message)
+        : base(message)
     {
-        /// <summary>
-        /// An unknown <see cref="IRegistration"/> was used
-        /// </summary>
-        /// <param name="message">The exception message</param>
-        public UnknownRegistrationException(string message)
-            : base(message)
-        {
 
-        }
     }
 }

LightweightIocContainer/Factories/CustomTypedFactory.cs

@@ -4,13 +4,12 @@
 
 using LightweightIocContainer.Interfaces.Factories;
 
-namespace LightweightIocContainer.Factories
+namespace LightweightIocContainer.Factories;
+
+/// <summary>
+/// <see cref="ITypedFactory"/> implementation for custom implemented factories
+/// </summary>
+public class CustomTypedFactory<TFactory> : TypedFactoryBase<TFactory>
 {
-    /// <summary>
-    /// <see cref="ITypedFactory"/> implementation for custom implemented factories
-    /// </summary>
-    public class CustomTypedFactory<TFactory> : TypedFactoryBase<TFactory>
-    {
         
-    }
 }

LightweightIocContainer/Factories/TypedFactory.cs

@@ -10,133 +10,132 @@ using LightweightIocContainer.Exceptions;
 using LightweightIocContainer.Interfaces;
 using LightweightIocContainer.Interfaces.Factories;
 
-namespace LightweightIocContainer.Factories
+namespace LightweightIocContainer.Factories;
+
+/// <summary>
+/// Class to help implement an abstract typed factory
+/// </summary>
+/// <typeparam name="TFactory">The type of the abstract factory</typeparam>
+public class TypedFactory<TFactory> : TypedFactoryBase<TFactory>, ITypedFactory<TFactory>
 {
+    private const string CLEAR_MULTITON_INSTANCE_METHOD_NAME = "ClearMultitonInstance";
+
+    /// <summary>
+    /// The 
+    /// </summary>
+    /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
+    public TypedFactory(IocContainer container) => Factory = CreateFactory(container);
+
     /// <summary>
-    /// Class to help implement an abstract typed factory
+    /// The implemented abstract typed factory/>
     /// </summary>
-    /// <typeparam name="TFactory">The type of the abstract factory</typeparam>
+    public TFactory Factory { get; set; }
-    public class TypedFactory<TFactory> : TypedFactoryBase<TFactory>, ITypedFactory<TFactory>
+        
+    /// <summary>
+    /// Creates the factory from the given abstract factory type
+    /// </summary>
+    /// <exception cref="InvalidFactoryRegistrationException">Factory registration is invalid</exception>
+    /// <exception cref="IllegalAbstractMethodCreationException">Creation of abstract methods are illegal in their current state</exception>
+    private TFactory CreateFactory(IocContainer container)
     {
-        private const string CLEAR_MULTITON_INSTANCE_METHOD_NAME = "ClearMultitonInstance";
+        Type factoryType = typeof(TFactory);
-
-        /// <summary>
-        /// The 
-        /// </summary>
-        /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-        public TypedFactory(IocContainer container) => Factory = CreateFactory(container);
-
-        /// <summary>
-        /// The implemented abstract typed factory/>
-        /// </summary>
-        public TFactory Factory { get; set; }
-        
-        /// <summary>
-        /// Creates the factory from the given abstract factory type
-        /// </summary>
-        /// <exception cref="InvalidFactoryRegistrationException">Factory registration is invalid</exception>
-        /// <exception cref="IllegalAbstractMethodCreationException">Creation of abstract methods are illegal in their current state</exception>
-        private TFactory CreateFactory(IocContainer container)
-        {
-            Type factoryType = typeof(TFactory);
             
-            AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("Factory"), AssemblyBuilderAccess.Run);
+        AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("Factory"), AssemblyBuilderAccess.Run);
-            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("Factory");
+        ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("Factory");
-            TypeBuilder typeBuilder = moduleBuilder.DefineType($"TypedFactory.{factoryType.Name}");
+        TypeBuilder typeBuilder = moduleBuilder.DefineType($"TypedFactory.{factoryType.Name}");
             
-            typeBuilder.AddInterfaceImplementation(factoryType);
+        typeBuilder.AddInterfaceImplementation(factoryType);
 
-            //add `private readonly IIocContainer _container` field
+        //add `private readonly IIocContainer _container` field
-            FieldBuilder containerFieldBuilder = typeBuilder.DefineField("_container", typeof(IocContainer), FieldAttributes.Private | FieldAttributes.InitOnly);
+        FieldBuilder containerFieldBuilder = typeBuilder.DefineField("_container", typeof(IocContainer), FieldAttributes.Private | FieldAttributes.InitOnly);
 
-            //add ctor
+        //add ctor
-            ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new[] {typeof(IocContainer)});
+        ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new[] {typeof(IocContainer)});
-            ILGenerator constructorGenerator = constructorBuilder.GetILGenerator();
+        ILGenerator constructorGenerator = constructorBuilder.GetILGenerator();
-            constructorGenerator.Emit(OpCodes.Ldarg_0);
+        constructorGenerator.Emit(OpCodes.Ldarg_0);
-            constructorGenerator.Emit(OpCodes.Ldarg_1);
+        constructorGenerator.Emit(OpCodes.Ldarg_1);
-            constructorGenerator.Emit(OpCodes.Stfld, containerFieldBuilder); //set `_container` field
+        constructorGenerator.Emit(OpCodes.Stfld, containerFieldBuilder); //set `_container` field
-            constructorGenerator.Emit(OpCodes.Ret);
+        constructorGenerator.Emit(OpCodes.Ret);
 
-            foreach (MethodInfo createMethod in CreateMethods)
+        foreach (MethodInfo createMethod in CreateMethods)
-            {
+        {
-                //create a method that looks like this
+            //create a method that looks like this
-                //public `createMethod.ReturnType` Create(`createMethod.GetParameters()`)
+            //public `createMethod.ReturnType` Create(`createMethod.GetParameters()`)
-                //{
+            //{
-                //    return IIocContainer.Resolve(`createMethod.ReturnType`, params);
+            //    return IIocContainer.Resolve(`createMethod.ReturnType`, params);
-                //}
+            //}
 
-                ParameterInfo[] args = createMethod.GetParameters();
+            ParameterInfo[] args = createMethod.GetParameters();
 
-                MethodBuilder methodBuilder = typeBuilder.DefineMethod(createMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual, 
+            MethodBuilder methodBuilder = typeBuilder.DefineMethod(createMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual, 
-                    createMethod.ReturnType, (from arg in args select arg.ParameterType).ToArray());
+                createMethod.ReturnType, (from arg in args select arg.ParameterType).ToArray());
-                typeBuilder.DefineMethodOverride(methodBuilder, createMethod);
+            typeBuilder.DefineMethodOverride(methodBuilder, createMethod);
 
-                ILGenerator generator = methodBuilder.GetILGenerator();
+            ILGenerator generator = methodBuilder.GetILGenerator();
 
-                generator.Emit(OpCodes.Ldarg_0);
+            generator.Emit(OpCodes.Ldarg_0);
-                generator.Emit(OpCodes.Ldfld, containerFieldBuilder);
+            generator.Emit(OpCodes.Ldfld, containerFieldBuilder);
 
-                if (args.Any())
+            if (args.Any())
-                {
+            {
-                    generator.Emit(OpCodes.Ldc_I4_S, args.Length);
+                generator.Emit(OpCodes.Ldc_I4_S, args.Length);
-                    generator.Emit(OpCodes.Newarr, typeof(object));
+                generator.Emit(OpCodes.Newarr, typeof(object));
-
+
-                    for (int i = 0; i < args.Length; i++)
+                for (int i = 0; i < args.Length; i++)
-                    {
-                        generator.Emit(OpCodes.Dup);
-                        generator.Emit(OpCodes.Ldc_I4_S, i);
-                        generator.Emit(OpCodes.Ldarg_S, i + 1);
-                        generator.Emit(OpCodes.Box, args[i].ParameterType); //Boxing is only needed for simple datatypes, but for now it is not a problem to box everything
-                        generator.Emit(OpCodes.Stelem_Ref);
-                    }
-                }
-                else
                 {
-                    MethodInfo emptyArray = typeof(Array).GetMethod(nameof(Array.Empty))!.MakeGenericMethod(typeof(object));
+                    generator.Emit(OpCodes.Dup);
-                    generator.EmitCall(OpCodes.Call, emptyArray, null);
+                    generator.Emit(OpCodes.Ldc_I4_S, i);
+                    generator.Emit(OpCodes.Ldarg_S, i + 1);
+                    generator.Emit(OpCodes.Box, args[i].ParameterType); //Boxing is only needed for simple datatypes, but for now it is not a problem to box everything
+                    generator.Emit(OpCodes.Stelem_Ref);
                 }
-
-                generator.EmitCall(OpCodes.Call, typeof(IocContainer).GetMethod(nameof(IocContainer.FactoryResolve), new[] { typeof(object[]) })!.MakeGenericMethod(createMethod.ReturnType), null);
-                generator.Emit(OpCodes.Castclass, createMethod.ReturnType);
-                generator.Emit(OpCodes.Ret);
             }
-
+            else
-            //if factory contains a method to clear multiton instances
-            MethodInfo? multitonClearMethod = factoryType.GetMethods().FirstOrDefault(m => m.Name.Equals(CLEAR_MULTITON_INSTANCE_METHOD_NAME));
-            if (multitonClearMethod != null)
             {
-                //create a method that looks like this
+                MethodInfo emptyArray = typeof(Array).GetMethod(nameof(Array.Empty))!.MakeGenericMethod(typeof(object));
-                //public void ClearMultitonInstance<typeToClear>()
+                generator.EmitCall(OpCodes.Call, emptyArray, null);
-                //{
+            }
-                //    IIocContainer.ClearMultitonInstances<typeToClear>();
-                //}
 
-                if (multitonClearMethod.IsGenericMethod)
+            generator.EmitCall(OpCodes.Call, typeof(IocContainer).GetMethod(nameof(IocContainer.FactoryResolve), new[] { typeof(object[]) })!.MakeGenericMethod(createMethod.ReturnType), null);
-                {
+            generator.Emit(OpCodes.Castclass, createMethod.ReturnType);
-                    Type? typeToClear = multitonClearMethod.GetGenericArguments().FirstOrDefault();
+            generator.Emit(OpCodes.Ret);
-                    if (typeToClear == null)
+        }
-                        throw new IllegalAbstractMethodCreationException("No Type to clear specified.", multitonClearMethod);
 
-                    MethodBuilder multitonClearMethodBuilder = typeBuilder.DefineMethod(multitonClearMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual,
+        //if factory contains a method to clear multiton instances
-                        multitonClearMethod.ReturnType, null);
+        MethodInfo? multitonClearMethod = factoryType.GetMethods().FirstOrDefault(m => m.Name.Equals(CLEAR_MULTITON_INSTANCE_METHOD_NAME));
-                    multitonClearMethodBuilder.DefineGenericParameters(typeToClear.Name);
+        if (multitonClearMethod != null)
+        {
+            //create a method that looks like this
+            //public void ClearMultitonInstance<typeToClear>()
+            //{
+            //    IIocContainer.ClearMultitonInstances<typeToClear>();
+            //}
 
-                    typeBuilder.DefineMethodOverride(multitonClearMethodBuilder, multitonClearMethod);
+            if (multitonClearMethod.IsGenericMethod)
+            {
+                Type? typeToClear = multitonClearMethod.GetGenericArguments().FirstOrDefault();
+                if (typeToClear == null)
+                    throw new IllegalAbstractMethodCreationException("No Type to clear specified.", multitonClearMethod);
 
-                    ILGenerator multitonClearGenerator = multitonClearMethodBuilder.GetILGenerator();
+                MethodBuilder multitonClearMethodBuilder = typeBuilder.DefineMethod(multitonClearMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual,
-                    multitonClearGenerator.Emit(OpCodes.Ldarg_0);
+                    multitonClearMethod.ReturnType, null);
-                    multitonClearGenerator.Emit(OpCodes.Ldfld, containerFieldBuilder);
+                multitonClearMethodBuilder.DefineGenericParameters(typeToClear.Name);
 
-                    multitonClearGenerator.EmitCall(OpCodes.Call, typeof(IocContainer).GetMethod(nameof(IocContainer.ClearMultitonInstances))!.MakeGenericMethod(typeToClear), null);
+                typeBuilder.DefineMethodOverride(multitonClearMethodBuilder, multitonClearMethod);
-                    multitonClearGenerator.Emit(OpCodes.Ret);
+
-                }
+                ILGenerator multitonClearGenerator = multitonClearMethodBuilder.GetILGenerator();
-                else
+                multitonClearGenerator.Emit(OpCodes.Ldarg_0);
-                {
+                multitonClearGenerator.Emit(OpCodes.Ldfld, containerFieldBuilder);
-                    throw new IllegalAbstractMethodCreationException("No Type to clear specified.", multitonClearMethod);
-                }
-            }
 
-            return Creator.CreateInstance<TFactory>(typeBuilder.CreateTypeInfo()!.AsType(), container);
+                multitonClearGenerator.EmitCall(OpCodes.Call, typeof(IocContainer).GetMethod(nameof(IocContainer.ClearMultitonInstances))!.MakeGenericMethod(typeToClear), null);
+                multitonClearGenerator.Emit(OpCodes.Ret);
+            }
+            else
+            {
+                throw new IllegalAbstractMethodCreationException("No Type to clear specified.", multitonClearMethod);
+            }
         }
+
+        return Creator.CreateInstance<TFactory>(typeBuilder.CreateTypeInfo()!.AsType(), container);
     }
 }

LightweightIocContainer/Factories/TypedFactoryBase.cs

@@ -9,28 +9,27 @@ using System.Reflection;
 using LightweightIocContainer.Exceptions;
 using LightweightIocContainer.Interfaces.Factories;
 
-namespace LightweightIocContainer.Factories
+namespace LightweightIocContainer.Factories;
+
+/// <summary>
+/// Base class for the <see cref="ITypedFactory"/>
+/// </summary>
+public abstract class TypedFactoryBase<TFactory> : ITypedFactory
 {
     /// <summary>
-    /// Base class for the <see cref="ITypedFactory"/>
+    /// The create methods of this <see cref="ITypedFactory"/>
     /// </summary>
-    public abstract class TypedFactoryBase<TFactory> : ITypedFactory
+    public List<MethodInfo> CreateMethods
     {
-        /// <summary>
+        get
-        /// The create methods of this <see cref="ITypedFactory"/>
-        /// </summary>
-        public List<MethodInfo> CreateMethods
         {
-            get
+            Type factoryType = typeof(TFactory);
-            {
-                Type factoryType = typeof(TFactory);
 
-                List<MethodInfo> createMethods = factoryType.GetMethods().Where(m => m.ReturnType != typeof(void)).ToList();
+            List<MethodInfo> createMethods = factoryType.GetMethods().Where(m => m.ReturnType != typeof(void)).ToList();
-                if (!createMethods.Any())
+            if (!createMethods.Any())
-                    throw new InvalidFactoryRegistrationException($"Factory {factoryType.Name} has no create methods.");
+                throw new InvalidFactoryRegistrationException($"Factory {factoryType.Name} has no create methods.");
 
-                return createMethods;
+            return createMethods;
-            }
         }
     }
 }

LightweightIocContainer/GenericMethodCaller.cs

@@ -6,53 +6,52 @@ using System;
 using System.Reflection;
 using LightweightIocContainer.Exceptions;
 
-namespace LightweightIocContainer
+namespace LightweightIocContainer;
+
+/// <summary>
+/// Helper class to call a generic method without generic type parameters 
+/// </summary>
+internal static class GenericMethodCaller
 {
     /// <summary>
-    /// Helper class to call a generic method without generic type parameters 
+    /// Call a generic method without generic type parameters
     /// </summary>
-    internal static class GenericMethodCaller
+    /// <param name="caller">The caller of the method</param>
+    /// <param name="functionName">The name of the method to call</param>
+    /// <param name="genericParameter">The generic parameter as <see cref="Type"/> parameter</param>
+    /// <param name="bindingFlags">The <see cref="BindingFlags"/> to find the method</param>
+    /// <param name="parameters">The parameters of the method</param>
+    /// <returns>The result of invoking the method</returns>
+    /// <exception cref="GenericMethodNotFoundException">Could not find the generic method</exception>
+    /// <exception cref="Exception">Any <see cref="Exception"/> thrown after invoking the generic method</exception>
+    public static object? Call(object caller, string functionName, Type genericParameter, BindingFlags bindingFlags, params object?[] parameters)
     {
-        /// <summary>
+        MethodInfo? method = caller.GetType().GetMethod(functionName, bindingFlags);
-        /// Call a generic method without generic type parameters
+        MethodInfo? genericMethod = method?.MakeGenericMethod(genericParameter);
-        /// </summary>
-        /// <param name="caller">The caller of the method</param>
-        /// <param name="functionName">The name of the method to call</param>
-        /// <param name="genericParameter">The generic parameter as <see cref="Type"/> parameter</param>
-        /// <param name="bindingFlags">The <see cref="BindingFlags"/> to find the method</param>
-        /// <param name="parameters">The parameters of the method</param>
-        /// <returns>The result of invoking the method</returns>
-        /// <exception cref="GenericMethodNotFoundException">Could not find the generic method</exception>
-        /// <exception cref="Exception">Any <see cref="Exception"/> thrown after invoking the generic method</exception>
-        public static object? Call(object caller, string functionName, Type genericParameter, BindingFlags bindingFlags, params object?[] parameters)
-        {
-            MethodInfo? method = caller.GetType().GetMethod(functionName, bindingFlags);
-            MethodInfo? genericMethod = method?.MakeGenericMethod(genericParameter);
 
-            if (genericMethod == null)
+        if (genericMethod == null)
-                throw new GenericMethodNotFoundException(functionName);
+            throw new GenericMethodNotFoundException(functionName);
 
-            try //exceptions thrown by methods called with invoke are wrapped into another exception, the exception thrown by the invoked method can be returned by `Exception.GetBaseException()`
+        try //exceptions thrown by methods called with invoke are wrapped into another exception, the exception thrown by the invoked method can be returned by `Exception.GetBaseException()`
-            {
+        {
-                return genericMethod.Invoke(caller, parameters);
+            return genericMethod.Invoke(caller, parameters);
-            }
+        }
-            catch (Exception ex)
+        catch (Exception ex)
-            {
+        {
-                throw ex.GetBaseException();
+            throw ex.GetBaseException();
-            }
         }
-
-        /// <summary>
-        /// Call a private generic method without generic type parameters
-        /// </summary>
-        /// <param name="caller">The caller of the method</param>
-        /// <param name="functionName">The name of the method to call</param>
-        /// <param name="genericParameter">The generic parameter as <see cref="Type"/> parameter</param>
-        /// <param name="parameters">The parameters of the method</param>
-        /// <returns>The result of invoking the method</returns>
-        /// <exception cref="GenericMethodNotFoundException">Could not find the generic method</exception>
-        /// <exception cref="Exception">Any <see cref="Exception"/> thrown after invoking the generic method</exception>
-        public static object? CallPrivate(object caller, string functionName, Type genericParameter, params object?[] parameters) =>
-            Call(caller, functionName, genericParameter, BindingFlags.NonPublic | BindingFlags.Instance, parameters);
     }
+
+    /// <summary>
+    /// Call a private generic method without generic type parameters
+    /// </summary>
+    /// <param name="caller">The caller of the method</param>
+    /// <param name="functionName">The name of the method to call</param>
+    /// <param name="genericParameter">The generic parameter as <see cref="Type"/> parameter</param>
+    /// <param name="parameters">The parameters of the method</param>
+    /// <returns>The result of invoking the method</returns>
+    /// <exception cref="GenericMethodNotFoundException">Could not find the generic method</exception>
+    /// <exception cref="Exception">Any <see cref="Exception"/> thrown after invoking the generic method</exception>
+    public static object? CallPrivate(object caller, string functionName, Type genericParameter, params object?[] parameters) =>
+        Call(caller, functionName, genericParameter, BindingFlags.NonPublic | BindingFlags.Instance, parameters);
 }

LightweightIocContainer/Installers/AssemblyInstaller.cs

@@ -9,44 +9,43 @@ using LightweightIocContainer.Interfaces;
 using LightweightIocContainer.Interfaces.Installers;
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Installers
+namespace LightweightIocContainer.Installers;
+
+/// <summary>
+/// An <see cref="IIocInstaller"/> that installs all <see cref="IIocInstaller"/>s for its given <see cref="Assembly"/>
+/// </summary>
+public class AssemblyInstaller : IAssemblyInstaller
 {
     /// <summary>
     /// An <see cref="IIocInstaller"/> that installs all <see cref="IIocInstaller"/>s for its given <see cref="Assembly"/>
     /// </summary>
-    public class AssemblyInstaller : IAssemblyInstaller
+    /// <param name="assembly">The <see cref="Assembly"/> from where the <see cref="IIocInstaller"/>s will be installed</param>
+    public AssemblyInstaller(Assembly assembly)
     {
-        /// <summary>
+        Installers = new List<IIocInstaller>();
-        /// An <see cref="IIocInstaller"/> that installs all <see cref="IIocInstaller"/>s for its given <see cref="Assembly"/>
-        /// </summary>
-        /// <param name="assembly">The <see cref="Assembly"/> from where the <see cref="IIocInstaller"/>s will be installed</param>
-        public AssemblyInstaller(Assembly assembly)
-        {
-            Installers = new List<IIocInstaller>();
 
-            Type[] types = assembly.GetTypes();
+        Type[] types = assembly.GetTypes();
-            foreach (Type type in types)
+        foreach (Type type in types)
-            {
+        {
-                if (!typeof(IIocInstaller).IsAssignableFrom(type) || type.IsNestedPrivate)
+            if (!typeof(IIocInstaller).IsAssignableFrom(type) || type.IsNestedPrivate)
-                    continue;
+                continue;
 
-                Installers.Add(Creator.CreateInstance<IIocInstaller>(type));
+            Installers.Add(Creator.CreateInstance<IIocInstaller>(type));
-            }
         }
+    }
 
-        /// <summary>
+    /// <summary>
-        /// The <see cref="IIocInstaller"/>s of the Assembly that this <see cref="AssemblyInstaller"/> is installing
+    /// The <see cref="IIocInstaller"/>s of the Assembly that this <see cref="AssemblyInstaller"/> is installing
-        /// </summary>
+    /// </summary>
-        public List<IIocInstaller> Installers { get; }
+    public List<IIocInstaller> Installers { get; }
 
-        /// <summary>
+    /// <summary>
-        /// Install the found <see cref="IIocInstaller"/>s in the given <see cref="IIocContainer"/>
+    /// Install the found <see cref="IIocInstaller"/>s in the given <see cref="IIocContainer"/>
-        /// </summary>
+    /// </summary>
-        /// <param name="registration">The <see cref="IRegistrationCollector"/> where <see cref="IRegistration"/>s are added</param>
+    /// <param name="registration">The <see cref="IRegistrationCollector"/> where <see cref="IRegistration"/>s are added</param>
-        public void Install(IRegistrationCollector registration)
+    public void Install(IRegistrationCollector registration)
-        {
+    {
-            foreach (IIocInstaller installer in Installers)
+        foreach (IIocInstaller installer in Installers)
-                installer.Install(registration);
+            installer.Install(registration);
-        }
     }
 }

LightweightIocContainer/Installers/FromAssembly.cs

@@ -5,28 +5,27 @@
 using System.Reflection;
 using LightweightIocContainer.Interfaces.Installers;
 
-namespace LightweightIocContainer.Installers
+namespace LightweightIocContainer.Installers;
+
+/// <summary>
+/// Helper class that supplies methods to find the wanted <see cref="Assembly"/>
+/// </summary>
+public static class FromAssembly
 {
     /// <summary>
-    /// Helper class that supplies methods to find the wanted <see cref="Assembly"/>
+    /// Get an <see cref="IAssemblyInstaller"/> that installs from the <see cref="Assembly"/> calling the method
     /// </summary>
-    public static class FromAssembly
+    /// <returns>A new <see cref="IAssemblyInstaller"/> with the calling <see cref="Assembly"/></returns>
+    public static IAssemblyInstaller This()
     {
-        /// <summary>
+        Assembly assembly = Assembly.GetCallingAssembly();
-        /// Get an <see cref="IAssemblyInstaller"/> that installs from the <see cref="Assembly"/> calling the method
+        return new AssemblyInstaller(assembly);
-        /// </summary>
-        /// <returns>A new <see cref="IAssemblyInstaller"/> with the calling <see cref="Assembly"/></returns>
-        public static IAssemblyInstaller This()
-        {
-            Assembly assembly = Assembly.GetCallingAssembly();
-            return new AssemblyInstaller(assembly);
-        }
-
-        /// <summary>
-        /// Get an <see cref="IAssemblyInstaller"/> that installs from the given <see cref="Assembly"/>
-        /// </summary>
-        /// <param name="assembly">The given <see cref="Assembly"/></param>
-        /// <returns>A new <see cref="IAssemblyInstaller"/> with the given <see cref="Assembly"/></returns>
-        public static IAssemblyInstaller Instance(Assembly assembly) => new AssemblyInstaller(assembly);
     }
+
+    /// <summary>
+    /// Get an <see cref="IAssemblyInstaller"/> that installs from the given <see cref="Assembly"/>
+    /// </summary>
+    /// <param name="assembly">The given <see cref="Assembly"/></param>
+    /// <returns>A new <see cref="IAssemblyInstaller"/> with the given <see cref="Assembly"/></returns>
+    public static IAssemblyInstaller Instance(Assembly assembly) => new AssemblyInstaller(assembly);
 }

LightweightIocContainer/Interfaces/Factories/ITypedFactory.cs

@@ -5,28 +5,27 @@
 using System.Collections.Generic;
 using System.Reflection;
 
-namespace LightweightIocContainer.Interfaces.Factories
+namespace LightweightIocContainer.Interfaces.Factories;
+
+/// <summary>
+/// Non-generic <see cref="ITypedFactory{TFactory}"/>
+/// </summary>
+public interface ITypedFactory
 {
     /// <summary>
-    /// Non-generic <see cref="ITypedFactory{TFactory}"/>
+    /// The create methods of this <see cref="ITypedFactory"/>
     /// </summary>
-    public interface ITypedFactory
+    List<MethodInfo> CreateMethods { get; }
-    {
+}
-        /// <summary>
-        /// The create methods of this <see cref="ITypedFactory"/>
-        /// </summary>
-        List<MethodInfo> CreateMethods { get; }
-    }
     
+/// <summary>
+/// Class to help implement an abstract typed factory
+/// </summary>
+/// <typeparam name="TFactory">The type of the abstract factory</typeparam>
+public interface ITypedFactory<TFactory> : ITypedFactory
+{
     /// <summary>
-    /// Class to help implement an abstract typed factory
+    /// The implemented abstract typed factory
     /// </summary>
-    /// <typeparam name="TFactory">The type of the abstract factory</typeparam>
+    TFactory Factory { get; set; }
-    public interface ITypedFactory<TFactory> : ITypedFactory
-    {
-        /// <summary>
-        /// The implemented abstract typed factory
-        /// </summary>
-        TFactory Factory { get; set; }
-    }
 }

LightweightIocContainer/Interfaces/IIocContainer.cs

@@ -6,37 +6,36 @@ using System;
 using LightweightIocContainer.Interfaces.Installers;
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Interfaces
+namespace LightweightIocContainer.Interfaces;
+
+/// <summary>
+/// The main container that carries all <see cref="IRegistration"/>s
+/// </summary>
+public interface IIocContainer : IDisposable
 {
     /// <summary>
-    /// The main container that carries all <see cref="IRegistration"/>s
+    /// Install the given installers for the current <see cref="IIocContainer"/>
     /// </summary>
-    public interface IIocContainer : IDisposable
+    /// <param name="installers">The given <see cref="IIocInstaller"/>s</param>
-    {
+    /// <returns>An instance of the current <see cref="IIocContainer"/></returns>
-        /// <summary>
+    IIocContainer Install(params IIocInstaller[] installers);
-        /// Install the given installers for the current <see cref="IIocContainer"/>
-        /// </summary>
-        /// <param name="installers">The given <see cref="IIocInstaller"/>s</param>
-        /// <returns>An instance of the current <see cref="IIocContainer"/></returns>
-        IIocContainer Install(params IIocInstaller[] installers);
 
-        /// <summary>
+    /// <summary>
-        /// Register an <see cref="IRegistration"/> at this <see cref="IocContainer"/> 
+    /// Register an <see cref="IRegistration"/> at this <see cref="IocContainer"/> 
-        /// </summary>
+    /// </summary>
-        /// <param name="addRegistration">The <see cref="Func{T, TResult}"/> that creates an <see cref="IRegistration"/></param>
+    /// <param name="addRegistration">The <see cref="Func{T, TResult}"/> that creates an <see cref="IRegistration"/></param>
-        public void Register(Func<IRegistrationCollector, IRegistration> addRegistration);
+    public void Register(Func<IRegistrationCollector, IRegistration> addRegistration);
 
-        /// <summary>
+    /// <summary>
-        /// Clear the multiton instances of the given <see cref="Type"/> from the registered multitons list
+    /// Clear the multiton instances of the given <see cref="Type"/> from the registered multitons list
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="T">The <see cref="Type"/> to clear the multiton instances</typeparam>
+    /// <typeparam name="T">The <see cref="Type"/> to clear the multiton instances</typeparam>
-        void ClearMultitonInstances<T>();
+    void ClearMultitonInstances<T>();
 
-        /// <summary>
+    /// <summary>
-        /// Is the given <see cref="Type"/> registered with this <see cref="IIocContainer"/>
+    /// Is the given <see cref="Type"/> registered with this <see cref="IIocContainer"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="T">The given <see cref="Type"/></typeparam>
+    /// <typeparam name="T">The given <see cref="Type"/></typeparam>
-        /// <returns>True if the given <see cref="Type"/> is registered with this <see cref="IIocContainer"/>, false if not</returns>
+    /// <returns>True if the given <see cref="Type"/> is registered with this <see cref="IIocContainer"/>, false if not</returns>
-        bool IsTypeRegistered<T>();
+    bool IsTypeRegistered<T>();
-    }
 }

LightweightIocContainer/Interfaces/IIocResolver.cs

@@ -4,26 +4,25 @@
 
 using System;
 
-namespace LightweightIocContainer.Interfaces
+namespace LightweightIocContainer.Interfaces;
+
+/// <summary>
+/// Provides <see cref="Resolve{T}()"/> methods
+/// </summary>
+public interface IIocResolver : IDisposable
 {
     /// <summary>
-    /// Provides <see cref="Resolve{T}()"/> methods
+    /// Gets an instance of the given <see cref="Type"/>
     /// </summary>
-    public interface IIocResolver : IDisposable
+    /// <typeparam name="T">The given <see cref="Type"/></typeparam>
-    {
+    /// <returns>An instance of the given <see cref="Type"/></returns>
-        /// <summary>
+    T Resolve<T>();
-        /// Gets an instance of the given <see cref="Type"/>
-        /// </summary>
-        /// <typeparam name="T">The given <see cref="Type"/></typeparam>
-        /// <returns>An instance of the given <see cref="Type"/></returns>
-        T Resolve<T>();
 
-        /// <summary>
+    /// <summary>
-        /// Gets an instance of the given <see cref="Type"/>
+    /// Gets an instance of the given <see cref="Type"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="T">The given <see cref="Type"/></typeparam>
+    /// <typeparam name="T">The given <see cref="Type"/></typeparam>
-        /// <param name="arguments">The constructor arguments</param>
+    /// <param name="arguments">The constructor arguments</param>
-        /// <returns>An instance of the given <see cref="Type"/></returns>
+    /// <returns>An instance of the given <see cref="Type"/></returns>
-        T Resolve<T>(params object[] arguments);
+    T Resolve<T>(params object[] arguments);
-    }
 }

LightweightIocContainer/Interfaces/Installers/IAssemblyInstaller.cs

@@ -5,16 +5,15 @@
 using System.Collections.Generic;
 using System.Reflection;
 
-namespace LightweightIocContainer.Interfaces.Installers
+namespace LightweightIocContainer.Interfaces.Installers;
+
+/// <summary>
+/// An <see cref="IIocInstaller"/> that installs all <see cref="IIocInstaller"/>s for its given <see cref="Assembly"/>
+/// </summary>
+public interface IAssemblyInstaller : IIocInstaller
 {
     /// <summary>
-    /// An <see cref="IIocInstaller"/> that installs all <see cref="IIocInstaller"/>s for its given <see cref="Assembly"/>
+    /// The <see cref="IIocInstaller"/>s of the <see cref="Assembly"/> that this <see cref="IAssemblyInstaller"/> is installing
     /// </summary>
-    public interface IAssemblyInstaller : IIocInstaller
+    List<IIocInstaller> Installers { get; }
-    {
-        /// <summary>
-        /// The <see cref="IIocInstaller"/>s of the <see cref="Assembly"/> that this <see cref="IAssemblyInstaller"/> is installing
-        /// </summary>
-        List<IIocInstaller> Installers { get; }
-    }
 }

LightweightIocContainer/Interfaces/Installers/IIocInstaller.cs

@@ -4,17 +4,16 @@
 
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Interfaces.Installers
+namespace LightweightIocContainer.Interfaces.Installers;
+
+/// <summary>
+/// The base class for <see cref="IIocContainer"/> installers
+/// </summary>
+public interface IIocInstaller
 {
     /// <summary>
-    /// The base class for <see cref="IIocContainer"/> installers
+    /// Install the needed <see cref="IRegistration"/>s in the given <see cref="IIocContainer"/>
     /// </summary>
-    public interface IIocInstaller
+    /// <param name="registration">The <see cref="IRegistrationCollector"/> where <see cref="IRegistration"/>s are added</param>
-    {
+    void Install(IRegistrationCollector registration);
-        /// <summary>
-        /// Install the needed <see cref="IRegistration"/>s in the given <see cref="IIocContainer"/>
-        /// </summary>
-        /// <param name="registration">The <see cref="IRegistrationCollector"/> where <see cref="IRegistration"/>s are added</param>
-        void Install(IRegistrationCollector registration);
-    }
 }

LightweightIocContainer/Interfaces/Registrations/Fluent/IOnCreate.cs

@@ -5,32 +5,31 @@
 using System;
 using LightweightIocContainer.Interfaces.Installers;
 
-namespace LightweightIocContainer.Interfaces.Registrations.Fluent
+namespace LightweightIocContainer.Interfaces.Registrations.Fluent;
+
+/// <summary>
+/// Provides an <see cref="OnCreateAction"/> to the generic <see cref="IOnCreate{TInterface, TImplementation}"/>
+/// </summary>
+public interface IOnCreate
 {
     /// <summary>
-    /// Provides an <see cref="OnCreateAction"/> to the generic <see cref="IOnCreate{TInterface, TImplementation}"/>
+    /// This <see cref="Action"/> is invoked when an instance of this type is created.
+    /// <para>Can be set in the <see cref="IIocInstaller"/> by calling <see cref="IOnCreate{TInterface, TImplementation}.OnCreate"/></para>
     /// </summary>
-    public interface IOnCreate
+    internal Action<object?>? OnCreateAction { get; }
-    {
+}
-        /// <summary>
-        /// This <see cref="Action"/> is invoked when an instance of this type is created.
-        /// <para>Can be set in the <see cref="IIocInstaller"/> by calling <see cref="IOnCreate{TInterface, TImplementation}.OnCreate"/></para>
-        /// </summary>
-        internal Action<object?>? OnCreateAction { get; }
-    }
 
+/// <summary>
+/// Provides an <see cref="OnCreate"/> method to an <see cref="IRegistrationBase"/>
+/// </summary>
+/// <typeparam name="TInterface">The registered interface</typeparam>
+/// <typeparam name="TImplementation">The registered implementation</typeparam>
+public interface IOnCreate<TInterface, TImplementation> : IOnCreate where TImplementation : TInterface
+{
     /// <summary>
-    /// Provides an <see cref="OnCreate"/> method to an <see cref="IRegistrationBase"/>
+    /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
     /// </summary>
-    /// <typeparam name="TInterface">The registered interface</typeparam>
+    /// <param name="action">The <see cref="Action{T}"/></param>
-    /// <typeparam name="TImplementation">The registered implementation</typeparam>
+    /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
-    public interface IOnCreate<TInterface, TImplementation> : IOnCreate where TImplementation : TInterface
+    ITypedRegistration<TInterface, TImplementation> OnCreate(Action<TImplementation?> action);
-    {
-        /// <summary>
-        /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
-        /// </summary>
-        /// <param name="action">The <see cref="Action{T}"/></param>
-        /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
-        ITypedRegistration<TInterface, TImplementation> OnCreate(Action<TImplementation?> action);
-    }
 }

LightweightIocContainer/Interfaces/Registrations/Fluent/IWithFactory.cs

@@ -4,34 +4,33 @@
 
 using LightweightIocContainer.Interfaces.Factories;
 
-namespace LightweightIocContainer.Interfaces.Registrations.Fluent
+namespace LightweightIocContainer.Interfaces.Registrations.Fluent;
+
+/// <summary>
+/// Provides a <see cref="WithFactory{TFactory}"/> method to an <see cref="IRegistrationBase"/>
+/// </summary>
+public interface IWithFactory
 {
     /// <summary>
-    /// Provides a <see cref="WithFactory{TFactory}"/> method to an <see cref="IRegistrationBase"/>
+    /// Register an abstract typed factory for the <see cref="IRegistrationBase"/> 
     /// </summary>
-    public interface IWithFactory
+    /// <typeparam name="TFactory">The type of the abstract typed factory</typeparam>
-    {
+    /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
-        /// <summary>
+    IRegistrationBase WithFactory<TFactory>();
-        /// Register an abstract typed factory for the <see cref="IRegistrationBase"/> 
-        /// </summary>
-        /// <typeparam name="TFactory">The type of the abstract typed factory</typeparam>
-        /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
-        IRegistrationBase WithFactory<TFactory>();
         
-        /// <summary>
+    /// <summary>
-        /// Register a custom implemented factory for the <see cref="IRegistrationBase"/>
+    /// Register a custom implemented factory for the <see cref="IRegistrationBase"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TFactoryInterface">The type of the interface for the custom factory</typeparam>
+    /// <typeparam name="TFactoryInterface">The type of the interface for the custom factory</typeparam>
-        /// <typeparam name="TFactoryImplementation">The type of the implementation for the custom factory</typeparam>
+    /// <typeparam name="TFactoryImplementation">The type of the implementation for the custom factory</typeparam>
-        /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
+    /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
-        IRegistrationBase WithFactory<TFactoryInterface, TFactoryImplementation>() where TFactoryImplementation : TFactoryInterface;
+    IRegistrationBase WithFactory<TFactoryInterface, TFactoryImplementation>() where TFactoryImplementation : TFactoryInterface;
-    }
+}
 
-    internal interface IWithFactoryInternal : IWithFactory
+internal interface IWithFactoryInternal : IWithFactory
-    {
+{
-        /// <summary>
+    /// <summary>
-        /// The Factory added with the <see cref="IWithFactory.WithFactory{TFactory}"/> method
+    /// The Factory added with the <see cref="IWithFactory.WithFactory{TFactory}"/> method
-        /// </summary>
+    /// </summary>
-        ITypedFactory? Factory { get; }
+    ITypedFactory? Factory { get; }
-    }
 }

LightweightIocContainer/Interfaces/Registrations/Fluent/IWithParameters.cs

@@ -6,38 +6,37 @@ using System;
 using LightweightIocContainer.Exceptions;
 using LightweightIocContainer.Interfaces.Installers;
 
-namespace LightweightIocContainer.Interfaces.Registrations.Fluent
+namespace LightweightIocContainer.Interfaces.Registrations.Fluent;
+
+/// <summary>
+/// Provides a <see cref="WithParameters(object[])"/> method to an <see cref="IRegistration"/>
+/// </summary>
+public interface IWithParameters
 {
     /// <summary>
-    /// Provides a <see cref="WithParameters(object[])"/> method to an <see cref="IRegistration"/>
+    /// Pass parameters that will be used to<see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
+    /// <para>Parameters set with this method are always inserted at the beginning of the argument list if more parameters are given when resolving</para>
     /// </summary>
-    public interface IWithParameters
+    /// <param name="parameters">The parameters</param>
-    {
+    /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
-        /// <summary>
+    /// <exception cref="InvalidRegistrationException"><see cref="IWithParametersInternal.Parameters"/> are already set or no parameters given</exception>
-        /// Pass parameters that will be used to<see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
+    IRegistrationBase WithParameters(params object[] parameters);
-        /// <para>Parameters set with this method are always inserted at the beginning of the argument list if more parameters are given when resolving</para>
-        /// </summary>
-        /// <param name="parameters">The parameters</param>
-        /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
-        /// <exception cref="InvalidRegistrationException"><see cref="IWithParametersInternal.Parameters"/> are already set or no parameters given</exception>
-        IRegistrationBase WithParameters(params object[] parameters);
 
-        /// <summary>
+    /// <summary>
-        /// Pass parameters that will be used to<see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
+    /// Pass parameters that will be used to<see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
-        /// <para>Parameters set with this method are inserted at the position in the argument list that is passed with the parameter if more parameters are given when resolving</para>
+    /// <para>Parameters set with this method are inserted at the position in the argument list that is passed with the parameter if more parameters are given when resolving</para>
-        /// </summary>
+    /// </summary>
-        /// <param name="parameters">The parameters with their position</param>
+    /// <param name="parameters">The parameters with their position</param>
-        /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
+    /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
-        /// <exception cref="InvalidRegistrationException"><see cref="IWithParametersInternal.Parameters"/> are already set or no parameters given</exception>
+    /// <exception cref="InvalidRegistrationException"><see cref="IWithParametersInternal.Parameters"/> are already set or no parameters given</exception>
-        IRegistrationBase WithParameters(params (int index, object parameter)[] parameters);
+    IRegistrationBase WithParameters(params (int index, object parameter)[] parameters);
-    }
+}
 
-    internal interface IWithParametersInternal : IWithParameters
+internal interface IWithParametersInternal : IWithParameters
-    {
+{
-        /// <summary>
+    /// <summary>
-        /// An <see cref="Array"/> of parameters that are used to <see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
+    /// An <see cref="Array"/> of parameters that are used to <see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
-        /// <para>Can be set in the <see cref="IIocInstaller"/> by calling <see cref="IWithParameters.WithParameters(object[])"/></para>
+    /// <para>Can be set in the <see cref="IIocInstaller"/> by calling <see cref="IWithParameters.WithParameters(object[])"/></para>
-        /// </summary>
+    /// </summary>
-        object[]? Parameters { get; }
+    object[]? Parameters { get; }
-    }
 }

LightweightIocContainer/Interfaces/Registrations/ILifestyleProvider.cs

@@ -2,16 +2,15 @@
 // // Created: 2020-01-29
 // // Copyright(c) 2020 SimonG. All Rights Reserved.
 
-namespace LightweightIocContainer.Interfaces.Registrations
+namespace LightweightIocContainer.Interfaces.Registrations;
+
+/// <summary>
+/// Provides a <see cref="LightweightIocContainer.Lifestyle"/> to an <see cref="IRegistration"/>
+/// </summary>
+public interface ILifestyleProvider
 {
     /// <summary>
-    /// Provides a <see cref="LightweightIocContainer.Lifestyle"/> to an <see cref="IRegistration"/>
+    /// The Lifestyle of Instances that are created with this <see cref="IRegistration"/>
     /// </summary>
-    public interface ILifestyleProvider
+    Lifestyle Lifestyle { get; }
-    {
-        /// <summary>
-        /// The Lifestyle of Instances that are created with this <see cref="IRegistration"/>
-        /// </summary>
-        Lifestyle Lifestyle { get; }
-    }
 }

LightweightIocContainer/Interfaces/Registrations/IMultipleMultitonRegistration.cs

@@ -2,16 +2,15 @@
 // Created: 2020-11-19
 // Copyright(c) 2020 SimonG. All Rights Reserved.
 
-namespace LightweightIocContainer.Interfaces.Registrations
+namespace LightweightIocContainer.Interfaces.Registrations;
+
+/// <summary>
+/// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type that implements them as a multiton
+/// </summary>
+/// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TInterface2">The second interface</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
+public interface IMultipleMultitonRegistration<TInterface1, TInterface2, TImplementation> : IMultitonRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TInterface2, TImplementation> where TImplementation : TInterface1, TInterface2
 {
-    /// <summary>
-    /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type that implements them as a multiton
-    /// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
-    /// <typeparam name="TInterface2">The second interface</typeparam>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
-    public interface IMultipleMultitonRegistration<TInterface1, TInterface2, TImplementation> : IMultitonRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TInterface2, TImplementation> where TImplementation : TInterface1, TInterface2
-    {
         
-    }
 }

LightweightIocContainer/Interfaces/Registrations/IMultipleRegistration.cs

@@ -4,68 +4,67 @@
 
 using System.Collections.Generic;
 
-namespace LightweightIocContainer.Interfaces.Registrations
+namespace LightweightIocContainer.Interfaces.Registrations;
+
+/// <summary>
+/// The base interface for every <see cref="IMultipleRegistration{TInterface1,TInterface2,TImplementation}"/> to register multiple interfaces
+/// </summary>
+/// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
+public interface IMultipleRegistration<TInterface1, TImplementation> : ITypedRegistration<TInterface1, TImplementation> where TImplementation : TInterface1
 {
     /// <summary>
-    /// The base interface for every <see cref="IMultipleRegistration{TInterface1,TInterface2,TImplementation}"/> to register multiple interfaces
+    /// A <see cref="List{T}"/> of <see cref="IRegistration"/>s that are registered within this <see cref="IMultipleRegistration{TInterface1,TImplementation}"/>
     /// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+    List<IRegistration> Registrations { get; }
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+}
-    public interface IMultipleRegistration<TInterface1, TImplementation> : ITypedRegistration<TInterface1, TImplementation> where TImplementation : TInterface1
-    {
-        /// <summary>
-        /// A <see cref="List{T}"/> of <see cref="IRegistration"/>s that are registered within this <see cref="IMultipleRegistration{TInterface1,TImplementation}"/>
-        /// </summary>
-        List<IRegistration> Registrations { get; }
-    }
 
-    /// <summary>
+/// <summary>
-    /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
+/// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
-    /// </summary>
+/// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TInterface1">The first interface</typeparam>
-    /// <typeparam name="TInterface2">The second interface</typeparam>
+/// <typeparam name="TInterface2">The second interface</typeparam>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
-    public interface IMultipleRegistration<TInterface1, TInterface2, TImplementation> : IMultipleRegistration<TInterface1, TImplementation> where TImplementation : TInterface1, TInterface2
+public interface IMultipleRegistration<TInterface1, TInterface2, TImplementation> : IMultipleRegistration<TInterface1, TImplementation> where TImplementation : TInterface1, TInterface2
-    {
+{
         
-    }
+}
 
-    /// <summary>
+/// <summary>
-    /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
+/// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
-    /// </summary>
+/// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TInterface1">The first interface</typeparam>
-    /// <typeparam name="TInterface2">The second interface</typeparam>
+/// <typeparam name="TInterface2">The second interface</typeparam>
-    /// <typeparam name="TInterface3">The third interface</typeparam>
+/// <typeparam name="TInterface3">The third interface</typeparam>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
-    public interface IMultipleRegistration<TInterface1, TInterface2, TInterface3, TImplementation> : IMultipleRegistration<TInterface1, TImplementation> where TImplementation : TInterface1, TInterface2, TInterface3
+public interface IMultipleRegistration<TInterface1, TInterface2, TInterface3, TImplementation> : IMultipleRegistration<TInterface1, TImplementation> where TImplementation : TInterface1, TInterface2, TInterface3
-    {
+{
 
-    }
+}
 
-    /// <summary>
+/// <summary>
-    /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
+/// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
-    /// </summary>
+/// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TInterface1">The first interface</typeparam>
-    /// <typeparam name="TInterface2">The second interface</typeparam>
+/// <typeparam name="TInterface2">The second interface</typeparam>
-    /// <typeparam name="TInterface3">The third interface</typeparam>
+/// <typeparam name="TInterface3">The third interface</typeparam>
-    /// <typeparam name="TInterface4">The fourth interface</typeparam>
+/// <typeparam name="TInterface4">The fourth interface</typeparam>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
-    public interface IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation> : IMultipleRegistration<TInterface1, TImplementation> where TImplementation : TInterface1, TInterface2, TInterface3, TInterface4
+public interface IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation> : IMultipleRegistration<TInterface1, TImplementation> where TImplementation : TInterface1, TInterface2, TInterface3, TInterface4
-    {
+{
 
-    }
+}
 
-    /// <summary>
+/// <summary>
-    /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
+/// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
-    /// </summary>
+/// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TInterface1">The first interface</typeparam>
-    /// <typeparam name="TInterface2">The second interface</typeparam>
+/// <typeparam name="TInterface2">The second interface</typeparam>
-    /// <typeparam name="TInterface3">The third interface</typeparam>
+/// <typeparam name="TInterface3">The third interface</typeparam>
-    /// <typeparam name="TInterface4">The fourth interface</typeparam>
+/// <typeparam name="TInterface4">The fourth interface</typeparam>
-    /// <typeparam name="TInterface5">The fifth interface</typeparam>
+/// <typeparam name="TInterface5">The fifth interface</typeparam>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
-    public interface IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation> : IMultipleRegistration<TInterface1, TImplementation> where TImplementation : TInterface1, TInterface2, TInterface3, TInterface4, TInterface5
+public interface IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation> : IMultipleRegistration<TInterface1, TImplementation> where TImplementation : TInterface1, TInterface2, TInterface3, TInterface4, TInterface5
-    {
+{
 
-    }
 }

LightweightIocContainer/Interfaces/Registrations/IMultitonRegistration.cs

@@ -4,26 +4,25 @@
 
 using System;
 
-namespace LightweightIocContainer.Interfaces.Registrations
+namespace LightweightIocContainer.Interfaces.Registrations;
+
+/// <summary>
+/// Non generic <see cref="IMultipleRegistration{TInterface1,TImplementation}"/>
+/// </summary>
+public interface IMultitonRegistration : ITypedRegistration
 {
     /// <summary>
-    /// Non generic <see cref="IMultipleRegistration{TInterface1,TImplementation}"/>
+    /// The <see cref="Type"/> of the multiton scope
     /// </summary>
-    public interface IMultitonRegistration : ITypedRegistration
+    Type Scope { get; }
-    {
+}
-        /// <summary>
-        /// The <see cref="Type"/> of the multiton scope
-        /// </summary>
-        Type Scope { get; }
-    }
 
-    /// <summary>
+/// <summary>
-    /// The registration that is used to register a multiton
+/// The registration that is used to register a multiton
-    /// </summary>
+/// </summary>
-    /// <typeparam name="TInterface">The registered interface</typeparam>
+/// <typeparam name="TInterface">The registered interface</typeparam>
-    /// <typeparam name="TImplementation">The registered implementation</typeparam>
+/// <typeparam name="TImplementation">The registered implementation</typeparam>
-    public interface IMultitonRegistration<TInterface, TImplementation> : IMultitonRegistration, ITypedRegistration<TInterface, TImplementation> where TImplementation : TInterface
+public interface IMultitonRegistration<TInterface, TImplementation> : IMultitonRegistration, ITypedRegistration<TInterface, TImplementation> where TImplementation : TInterface
-    {
+{
         
-    }
 }

LightweightIocContainer/Interfaces/Registrations/IOpenGenericRegistration.cs

@@ -2,13 +2,12 @@
 // Created: 2020-09-18
 // Copyright(c) 2020 SimonG. All Rights Reserved.
 
-namespace LightweightIocContainer.Interfaces.Registrations
+namespace LightweightIocContainer.Interfaces.Registrations;
+
+/// <summary>
+/// <see cref="IRegistration"/> for open generic types
+/// </summary>
+public interface IOpenGenericRegistration : ITypedRegistration
 {
-    /// <summary>
-    /// <see cref="IRegistration"/> for open generic types
-    /// </summary>
-    public interface IOpenGenericRegistration : ITypedRegistration
-    {
         
-    }
 }

LightweightIocContainer/Interfaces/Registrations/IRegistration.cs

@@ -4,16 +4,15 @@
 
 using System;
 
-namespace LightweightIocContainer.Interfaces.Registrations
+namespace LightweightIocContainer.Interfaces.Registrations;
+
+/// <summary>
+/// The base registration that is used to register an Interface
+/// </summary>
+public interface IRegistration
 {
     /// <summary>
-    /// The base registration that is used to register an Interface
+    /// The <see cref="Type"/> of the Interface that is registered with this <see cref="IRegistration"/>
     /// </summary>
-    public interface IRegistration
+    Type InterfaceType { get; }
-    {
-        /// <summary>
-        /// The <see cref="Type"/> of the Interface that is registered with this <see cref="IRegistration"/>
-        /// </summary>
-        Type InterfaceType { get; }
-    }
 }

LightweightIocContainer/Interfaces/Registrations/IRegistrationBase.cs

@@ -4,13 +4,12 @@
 
 using LightweightIocContainer.Interfaces.Registrations.Fluent;
 
-namespace LightweightIocContainer.Interfaces.Registrations
+namespace LightweightIocContainer.Interfaces.Registrations;
+
+/// <summary>
+/// The <see cref="IRegistrationBase"/> that is used to register an Interface and extends the <see cref="IRegistration"/> with fluent options
+/// </summary>
+public interface IRegistrationBase : IRegistration, IWithFactory, IWithParameters, IWithDisposeStrategy
 {
-    /// <summary>
-    /// The <see cref="IRegistrationBase"/> that is used to register an Interface and extends the <see cref="IRegistration"/> with fluent options
-    /// </summary>
-    public interface IRegistrationBase : IRegistration, IWithFactory, IWithParameters, IWithDisposeStrategy
-    {
         
-    }
 }

LightweightIocContainer/Interfaces/Registrations/ISingleTypeRegistration.cs

@@ -4,24 +4,23 @@
 
 using System;
 
-namespace LightweightIocContainer.Interfaces.Registrations
+namespace LightweightIocContainer.Interfaces.Registrations;
+
+/// <summary>
+/// The <see cref="IRegistration"/> to register either only an interface or only a <see cref="Type"/>
+/// </summary>
+/// <typeparam name="T">The <see cref="Type"/> of the <see cref="IRegistration"/></typeparam>
+public interface ISingleTypeRegistration<T> : IRegistrationBase
 {
     /// <summary>
-    /// The <see cref="IRegistration"/> to register either only an interface or only a <see cref="Type"/>
+    /// <see cref="Func{T,TResult}"/> that is invoked instead of creating an instance of this <see cref="Type"/> the default way
     /// </summary>
-    /// <typeparam name="T">The <see cref="Type"/> of the <see cref="IRegistration"/></typeparam>
+    Func<IIocResolver, T>? FactoryMethod { get; }
-    public interface ISingleTypeRegistration<T> : IRegistrationBase
-    {
-        /// <summary>
-        /// <see cref="Func{T,TResult}"/> that is invoked instead of creating an instance of this <see cref="Type"/> the default way
-        /// </summary>
-        Func<IIocResolver, T>? FactoryMethod { get; }
 
-        /// <summary>
+    /// <summary>
-        /// Pass a <see cref="Func{T,TResult}"/> that will be invoked instead of creating an instance of this <see cref="Type"/> the default way
+    /// Pass a <see cref="Func{T,TResult}"/> that will be invoked instead of creating an instance of this <see cref="Type"/> the default way
-        /// </summary>
+    /// </summary>
-        /// <param name="factoryMethod">The <see cref="Func{T,TResult}"/></param>
+    /// <param name="factoryMethod">The <see cref="Func{T,TResult}"/></param>
-        /// <returns>The current instance of this <see cref="IRegistration"/></returns>
+    /// <returns>The current instance of this <see cref="IRegistration"/></returns>
-        ISingleTypeRegistration<T> WithFactoryMethod(Func<IIocResolver, T> factoryMethod);
+    ISingleTypeRegistration<T> WithFactoryMethod(Func<IIocResolver, T> factoryMethod);
-    }
 }

LightweightIocContainer/Interfaces/Registrations/ITypedFactoryRegistration.cs

@@ -4,17 +4,16 @@
 
 using LightweightIocContainer.Interfaces.Factories;
 
-namespace LightweightIocContainer.Interfaces.Registrations
+namespace LightweightIocContainer.Interfaces.Registrations;
+
+/// <summary>
+/// The registration that is used to register an abstract typed factory
+/// </summary>
+/// <typeparam name="TFactory">The type of the abstract typed factory</typeparam>
+public interface ITypedFactoryRegistration<TFactory> : IRegistration
 {
     /// <summary>
-    /// The registration that is used to register an abstract typed factory
+    /// The class that contains the implemented abstract factory of this <see cref="ITypedFactoryRegistration{TFactory}"/>
     /// </summary>
-    /// <typeparam name="TFactory">The type of the abstract typed factory</typeparam>
+    ITypedFactory<TFactory> Factory { get; }
-    public interface ITypedFactoryRegistration<TFactory> : IRegistration
-    {
-        /// <summary>
-        /// The class that contains the implemented abstract factory of this <see cref="ITypedFactoryRegistration{TFactory}"/>
-        /// </summary>
-        ITypedFactory<TFactory> Factory { get; }
-    }
 }

LightweightIocContainer/Interfaces/Registrations/ITypedRegistration.cs

@@ -5,24 +5,23 @@
 using System;
 using LightweightIocContainer.Interfaces.Registrations.Fluent;
 
-namespace LightweightIocContainer.Interfaces.Registrations
+namespace LightweightIocContainer.Interfaces.Registrations;
+
+/// <summary>
+/// A base <see cref="ITypedRegistration"/> without generic interface and implementation
+/// </summary>
+public interface ITypedRegistration : IRegistrationBase
 {
     /// <summary>
-    /// A base <see cref="ITypedRegistration"/> without generic interface and implementation
+    /// The <see cref="Type"/> that implements the <see cref="IRegistration.InterfaceType"/> that is registered with this <see cref="IRegistration"/>
     /// </summary>
-    public interface ITypedRegistration : IRegistrationBase
+    Type ImplementationType { get; }
-    {
+}
-        /// <summary>
-        /// The <see cref="Type"/> that implements the <see cref="IRegistration.InterfaceType"/> that is registered with this <see cref="IRegistration"/>
-        /// </summary>
-        Type ImplementationType { get; }
-    }
     
-    /// <summary>
+/// <summary>
-    /// A <see cref="IRegistration"/> that implements a <see cref="Type"/>
+/// A <see cref="IRegistration"/> that implements a <see cref="Type"/>
-    /// </summary>
+/// </summary>
-    public interface ITypedRegistration<TInterface, TImplementation> : ITypedRegistration, IOnCreate<TInterface, TImplementation> where TImplementation : TInterface
+public interface ITypedRegistration<TInterface, TImplementation> : ITypedRegistration, IOnCreate<TInterface, TImplementation> where TImplementation : TInterface
-    {
+{
         
-    }
 }

LightweightIocContainer/Lifestyle.cs

@@ -4,26 +4,25 @@
 
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer
+namespace LightweightIocContainer;
+
+/// <summary>
+/// The Lifestyles that can be used for a <see cref="IRegistrationBase"/>
+/// </summary>
+public enum Lifestyle
 {
     /// <summary>
-    /// The Lifestyles that can be used for a <see cref="IRegistrationBase"/>
+    /// A new instance gets created every time an instance is resolved
     /// </summary>
-    public enum Lifestyle
+    Transient,
-    {
-        /// <summary>
-        /// A new instance gets created every time an instance is resolved
-        /// </summary>
-        Transient,
 
-        /// <summary>
+    /// <summary>
-        /// One instance is created that gets returned every time an instance is resolved
+    /// One instance is created that gets returned every time an instance is resolved
-        /// </summary>
+    /// </summary>
-        Singleton,
+    Singleton,
 
-        /// <summary>
+    /// <summary>
-        /// A new instance gets created if the given scope has no created instance yet. Otherwise the already created instance is used.
+    /// A new instance gets created if the given scope has no created instance yet. Otherwise the already created instance is used.
-        /// </summary>
+    /// </summary>
-        Multiton
+    Multiton
-    }
 }

LightweightIocContainer/Registrations/MultipleMultitonRegistration.cs

@@ -7,55 +7,54 @@ using System.Collections.Generic;
 using LightweightIocContainer.Interfaces;
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Registrations
+namespace LightweightIocContainer.Registrations;
+
+/// <summary>
+/// An <see cref="IRegistrationBase"/> to register multiple interfaces for on implementation type that implements them as a multiton
+/// </summary>
+/// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TInterface2">The second interface</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
+internal class MultipleMultitonRegistration<TInterface1, TInterface2, TImplementation> : MultitonRegistration<TInterface1, TImplementation>, IMultipleMultitonRegistration<TInterface1, TInterface2, TImplementation> where TImplementation : TInterface1, TInterface2
 {
     /// <summary>
     /// An <see cref="IRegistrationBase"/> to register multiple interfaces for on implementation type that implements them as a multiton
     /// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+    /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-    /// <typeparam name="TInterface2">The second interface</typeparam>
+    /// <param name="interfaceType2">The <see cref="Type"/> of the second interface</param>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+    /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-    internal class MultipleMultitonRegistration<TInterface1, TInterface2, TImplementation> : MultitonRegistration<TInterface1, TImplementation>, IMultipleMultitonRegistration<TInterface1, TInterface2, TImplementation> where TImplementation : TInterface1, TInterface2
+    /// <param name="scope">The <see cref="Type"/> of the multiton scope</param>
+    /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
+    public MultipleMultitonRegistration(Type interfaceType1, Type interfaceType2, Type implementationType, Type scope, IocContainer container)
+        : base(interfaceType1, implementationType, scope, container)
     {
-        /// <summary>
+        Registrations = new List<IRegistration>
-        /// An <see cref="IRegistrationBase"/> to register multiple interfaces for on implementation type that implements them as a multiton
-        /// </summary>
-        /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-        /// <param name="interfaceType2">The <see cref="Type"/> of the second interface</param>
-        /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-        /// <param name="scope">The <see cref="Type"/> of the multiton scope</param>
-        /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-        public MultipleMultitonRegistration(Type interfaceType1, Type interfaceType2, Type implementationType, Type scope, IocContainer container)
-            : base(interfaceType1, implementationType, scope, container)
         {
-            Registrations = new List<IRegistration>
+            new MultitonRegistration<TInterface1, TImplementation>(interfaceType1, implementationType, scope, container),
-            {
+            new MultitonRegistration<TInterface2, TImplementation>(interfaceType2, implementationType, scope, container)
-                new MultitonRegistration<TInterface1, TImplementation>(interfaceType1, implementationType, scope, container),
+        };
-                new MultitonRegistration<TInterface2, TImplementation>(interfaceType2, implementationType, scope, container)
+    }
-            };
-        }
 
-        /// <summary>
+    /// <summary>
-        /// A <see cref="List{T}"/> of <see cref="IRegistration"/>s that are registered within this <see cref="IMultipleRegistration{TInterface1,TImplementation}"/>
+    /// A <see cref="List{T}"/> of <see cref="IRegistration"/>s that are registered within this <see cref="IMultipleRegistration{TInterface1,TImplementation}"/>
-        /// </summary>
+    /// </summary>
-        public List<IRegistration> Registrations { get; }
+    public List<IRegistration> Registrations { get; }
 
-        /// <summary>
+    /// <summary>
-        /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
+    /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
-        /// </summary>
+    /// </summary>
-        /// <param name="action">The <see cref="Action{T}"/></param>
+    /// <param name="action">The <see cref="Action{T}"/></param>
-        /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
+    /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
-        public override ITypedRegistration<TInterface1, TImplementation> OnCreate(Action<TImplementation?> action)
+    public override ITypedRegistration<TInterface1, TImplementation> OnCreate(Action<TImplementation?> action)
+    {
+        foreach (IRegistration registration in Registrations)
         {
-            foreach (IRegistration registration in Registrations)
+            if (registration is IMultitonRegistration<TInterface2, TImplementation> interface2Registration)
-            {
+                interface2Registration.OnCreate(action);
-                if (registration is IMultitonRegistration<TInterface2, TImplementation> interface2Registration)
+            else if (registration is IMultitonRegistration<TInterface1, TImplementation> interface1Registration)
-                    interface2Registration.OnCreate(action);
+                interface1Registration.OnCreate(action);
-                else if (registration is IMultitonRegistration<TInterface1, TImplementation> interface1Registration)
-                    interface1Registration.OnCreate(action);
-            }
-
-            return this;
         }
+
+        return this;
     }
 }

LightweightIocContainer/Registrations/MultipleRegistration.cs

@@ -7,239 +7,238 @@ using System.Collections.Generic;
 using LightweightIocContainer.Interfaces;
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Registrations
+namespace LightweightIocContainer.Registrations;
+
+/// <summary>
+/// The base class for every <see cref="IMultipleRegistration{TInterface1,TInterface2, TImplementation}"/> to register multiple interfaces
+/// </summary>
+/// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
+internal abstract class MultipleRegistration<TInterface1, TImplementation> : TypedRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TImplementation> where TImplementation : TInterface1
 {
     /// <summary>
-    /// The base class for every <see cref="IMultipleRegistration{TInterface1,TInterface2, TImplementation}"/> to register multiple interfaces
+    /// The base class for every <see cref="IMultipleRegistration{TInterface1,TInterface2}"/> to register multiple interfaces
     /// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+    /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+    /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-    internal abstract class MultipleRegistration<TInterface1, TImplementation> : TypedRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TImplementation> where TImplementation : TInterface1
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="MultipleRegistration{TInterface1,TInterface2}"/></param>
-    {
+    /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-        /// <summary>
+    protected MultipleRegistration(Type interfaceType1, Type implementationType, Lifestyle lifestyle, IocContainer container)
-        /// The base class for every <see cref="IMultipleRegistration{TInterface1,TInterface2}"/> to register multiple interfaces
+        : base(interfaceType1, implementationType, lifestyle, container) =>
-        /// </summary>
+        Registrations = new List<IRegistration>();
-        /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
+
-        /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
+    /// <summary>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="MultipleRegistration{TInterface1,TInterface2}"/></param>
+    /// A <see cref="List{T}"/> of <see cref="IRegistration"/>s that are registered within this <see cref="MultipleRegistration{TInterface1,TInterface2}"/>
-        /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
+    /// </summary>
-        protected MultipleRegistration(Type interfaceType1, Type implementationType, Lifestyle lifestyle, IocContainer container)
+    public List<IRegistration> Registrations { get; protected init; }
-            : base(interfaceType1, implementationType, lifestyle, container) =>
+}
-            Registrations = new List<IRegistration>();
-
-        /// <summary>
-        /// A <see cref="List{T}"/> of <see cref="IRegistration"/>s that are registered within this <see cref="MultipleRegistration{TInterface1,TInterface2}"/>
-        /// </summary>
-        public List<IRegistration> Registrations { get; protected init; }
-    }
 
+/// <summary>
+/// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
+/// </summary>
+/// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TInterface2">The second interface</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
+internal class MultipleRegistration<TInterface1, TInterface2, TImplementation> : MultipleRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TInterface2, TImplementation> where TImplementation : TInterface1, TInterface2
+{
     /// <summary>
     /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
     /// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+    /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-    /// <typeparam name="TInterface2">The second interface</typeparam>
+    /// <param name="interfaceType2">The <see cref="Type"/> of the second interface</param>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+    /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-    internal class MultipleRegistration<TInterface1, TInterface2, TImplementation> : MultipleRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TInterface2, TImplementation> where TImplementation : TInterface1, TInterface2
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="MultipleRegistration{TInterface1,TInterface2}"/></param>
+    /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
+    public MultipleRegistration(Type interfaceType1, Type interfaceType2, Type implementationType, Lifestyle lifestyle, IocContainer container)
+        : base(interfaceType1, implementationType, lifestyle, container)
     {
-        /// <summary>
+        Registrations = new List<IRegistration>
-        /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
-        /// </summary>
-        /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-        /// <param name="interfaceType2">The <see cref="Type"/> of the second interface</param>
-        /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="MultipleRegistration{TInterface1,TInterface2}"/></param>
-        /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-        public MultipleRegistration(Type interfaceType1, Type interfaceType2, Type implementationType, Lifestyle lifestyle, IocContainer container)
-            : base(interfaceType1, implementationType, lifestyle, container)
         { 
-            Registrations = new List<IRegistration>
+            new TypedRegistration<TInterface1, TImplementation>(interfaceType1, implementationType, lifestyle, container),
-            { 
+            new TypedRegistration<TInterface2, TImplementation>(interfaceType2, implementationType, lifestyle, container)
-                new TypedRegistration<TInterface1, TImplementation>(interfaceType1, implementationType, lifestyle, container),
+        };
-                new TypedRegistration<TInterface2, TImplementation>(interfaceType2, implementationType, lifestyle, container)
+    }
-            };
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
+    /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
-        /// </summary>
+    /// </summary>
-        /// <param name="action">The <see cref="Action{T}"/></param>
+    /// <param name="action">The <see cref="Action{T}"/></param>
-        /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
+    /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
-        public override ITypedRegistration<TInterface1, TImplementation> OnCreate(Action<TImplementation?> action)
+    public override ITypedRegistration<TInterface1, TImplementation> OnCreate(Action<TImplementation?> action)
+    {
+        foreach (IRegistration registration in Registrations)
         {
-            foreach (IRegistration registration in Registrations)
+            if (registration is ITypedRegistration<TInterface2, TImplementation> interface2Registration)
-            {
+                interface2Registration.OnCreate(action);
-                if (registration is ITypedRegistration<TInterface2, TImplementation> interface2Registration)
+            else if (registration is ITypedRegistration<TInterface1, TImplementation> interface1Registration)
-                    interface2Registration.OnCreate(action);
+                interface1Registration.OnCreate(action);
-                else if (registration is ITypedRegistration<TInterface1, TImplementation> interface1Registration)
-                    interface1Registration.OnCreate(action);
-            }
-
-            return this;
         }
+
+        return this;
     }
+}
 
+/// <summary>
+/// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
+/// </summary>
+/// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TInterface2">The second interface</typeparam>
+/// <typeparam name="TInterface3">The third interface</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
+internal class MultipleRegistration<TInterface1, TInterface2, TInterface3, TImplementation> : MultipleRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TInterface2, TInterface3, TImplementation> where TImplementation : TInterface3, TInterface2, TInterface1
+{
     /// <summary>
     /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
     /// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+    /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-    /// <typeparam name="TInterface2">The second interface</typeparam>
+    /// <param name="interfaceType2">The <see cref="Type"/> of the second interface</param>
-    /// <typeparam name="TInterface3">The third interface</typeparam>
+    /// <param name="interfaceType3">The <see cref="Type"/> of the third interface</param>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+    /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-    internal class MultipleRegistration<TInterface1, TInterface2, TInterface3, TImplementation> : MultipleRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TInterface2, TInterface3, TImplementation> where TImplementation : TInterface3, TInterface2, TInterface1
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="MultipleRegistration{TInterface1,TInterface2}"/></param>
+    /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
+    public MultipleRegistration(Type interfaceType1, Type interfaceType2, Type interfaceType3, Type implementationType, Lifestyle lifestyle, IocContainer container)
+        : base(interfaceType1, implementationType, lifestyle, container)
     {
-        /// <summary>
+        Registrations = new List<IRegistration>
-        /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
-        /// </summary>
-        /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-        /// <param name="interfaceType2">The <see cref="Type"/> of the second interface</param>
-        /// <param name="interfaceType3">The <see cref="Type"/> of the third interface</param>
-        /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="MultipleRegistration{TInterface1,TInterface2}"/></param>
-        /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-        public MultipleRegistration(Type interfaceType1, Type interfaceType2, Type interfaceType3, Type implementationType, Lifestyle lifestyle, IocContainer container)
-            : base(interfaceType1, implementationType, lifestyle, container)
         {
-            Registrations = new List<IRegistration>
+            new TypedRegistration<TInterface1, TImplementation>(interfaceType1, implementationType, lifestyle, container),
-            {
+            new TypedRegistration<TInterface2, TImplementation>(interfaceType2, implementationType, lifestyle, container),
-                new TypedRegistration<TInterface1, TImplementation>(interfaceType1, implementationType, lifestyle, container),
+            new TypedRegistration<TInterface3, TImplementation>(interfaceType3, implementationType, lifestyle, container)
-                new TypedRegistration<TInterface2, TImplementation>(interfaceType2, implementationType, lifestyle, container),
+        };
-                new TypedRegistration<TInterface3, TImplementation>(interfaceType3, implementationType, lifestyle, container)
+    }
-            };
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
+    /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
-        /// </summary>
+    /// </summary>
-        /// <param name="action">The <see cref="Action{T}"/></param>
+    /// <param name="action">The <see cref="Action{T}"/></param>
-        /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
+    /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
-        public override ITypedRegistration<TInterface1, TImplementation> OnCreate(Action<TImplementation?> action)
+    public override ITypedRegistration<TInterface1, TImplementation> OnCreate(Action<TImplementation?> action)
+    {
+        foreach (IRegistration registration in Registrations)
         {
-            foreach (IRegistration registration in Registrations)
+            if (registration is ITypedRegistration<TInterface3, TImplementation> interface3Registration)
-            {
+                interface3Registration.OnCreate(action);
-                if (registration is ITypedRegistration<TInterface3, TImplementation> interface3Registration)
+            else if (registration is ITypedRegistration<TInterface2, TImplementation> interface2Registration)
-                    interface3Registration.OnCreate(action);
+                interface2Registration.OnCreate(action);
-                else if (registration is ITypedRegistration<TInterface2, TImplementation> interface2Registration)
+            else if (registration is ITypedRegistration<TInterface1, TImplementation> interface1Registration)
-                    interface2Registration.OnCreate(action);
+                interface1Registration.OnCreate(action);
-                else if (registration is ITypedRegistration<TInterface1, TImplementation> interface1Registration)
-                    interface1Registration.OnCreate(action);
-            }
-
-            return this;
         }
+
+        return this;
     }
+}
 
+/// <summary>
+/// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
+/// </summary>
+/// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TInterface2">The second interface</typeparam>
+/// <typeparam name="TInterface3">The third interface</typeparam>
+/// <typeparam name="TInterface4">The fourth interface</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
+internal class MultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation> : MultipleRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation> where TImplementation : TInterface4, TInterface3, TInterface2, TInterface1
+{
     /// <summary>
     /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
     /// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+    /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-    /// <typeparam name="TInterface2">The second interface</typeparam>
+    /// <param name="interfaceType2">The <see cref="Type"/> of the second interface</param>
-    /// <typeparam name="TInterface3">The third interface</typeparam>
+    /// <param name="interfaceType3">The <see cref="Type"/> of the third interface</param>
-    /// <typeparam name="TInterface4">The fourth interface</typeparam>
+    /// <param name="interfaceType4">The <see cref="Type"/> of the fourth interface</param>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+    /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-    internal class MultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation> : MultipleRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation> where TImplementation : TInterface4, TInterface3, TInterface2, TInterface1
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="MultipleRegistration{TInterface1,TInterface2}"/></param>
+    /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
+    public MultipleRegistration(Type interfaceType1, Type interfaceType2, Type interfaceType3, Type interfaceType4, Type implementationType, Lifestyle lifestyle, IocContainer container)
+        : base(interfaceType1, implementationType, lifestyle, container)
     {
-        /// <summary>
+        Registrations = new List<IRegistration>
-        /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
-        /// </summary>
-        /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-        /// <param name="interfaceType2">The <see cref="Type"/> of the second interface</param>
-        /// <param name="interfaceType3">The <see cref="Type"/> of the third interface</param>
-        /// <param name="interfaceType4">The <see cref="Type"/> of the fourth interface</param>
-        /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="MultipleRegistration{TInterface1,TInterface2}"/></param>
-        /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-        public MultipleRegistration(Type interfaceType1, Type interfaceType2, Type interfaceType3, Type interfaceType4, Type implementationType, Lifestyle lifestyle, IocContainer container)
-            : base(interfaceType1, implementationType, lifestyle, container)
         {
-            Registrations = new List<IRegistration>
+            new TypedRegistration<TInterface1, TImplementation>(interfaceType1, implementationType, lifestyle, container),
-            {
+            new TypedRegistration<TInterface2, TImplementation>(interfaceType2, implementationType, lifestyle, container),
-                new TypedRegistration<TInterface1, TImplementation>(interfaceType1, implementationType, lifestyle, container),
+            new TypedRegistration<TInterface3, TImplementation>(interfaceType3, implementationType, lifestyle, container),
-                new TypedRegistration<TInterface2, TImplementation>(interfaceType2, implementationType, lifestyle, container),
+            new TypedRegistration<TInterface4, TImplementation>(interfaceType4, implementationType, lifestyle, container)
-                new TypedRegistration<TInterface3, TImplementation>(interfaceType3, implementationType, lifestyle, container),
+        };
-                new TypedRegistration<TInterface4, TImplementation>(interfaceType4, implementationType, lifestyle, container)
+    }
-            };
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
+    /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
-        /// </summary>
+    /// </summary>
-        /// <param name="action">The <see cref="Action{T}"/></param>
+    /// <param name="action">The <see cref="Action{T}"/></param>
-        /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
+    /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
-        public override ITypedRegistration<TInterface1, TImplementation> OnCreate(Action<TImplementation?> action)
+    public override ITypedRegistration<TInterface1, TImplementation> OnCreate(Action<TImplementation?> action)
+    {
+        foreach (IRegistration registration in Registrations)
         {
-            foreach (IRegistration registration in Registrations)
+            if (registration is ITypedRegistration<TInterface4, TImplementation> interface4Registration)
-            {
+                interface4Registration.OnCreate(action);
-                if (registration is ITypedRegistration<TInterface4, TImplementation> interface4Registration)
+            else if (registration is ITypedRegistration<TInterface3, TImplementation> interface3Registration)
-                    interface4Registration.OnCreate(action);
+                interface3Registration.OnCreate(action);
-                else if (registration is ITypedRegistration<TInterface3, TImplementation> interface3Registration)
+            else if (registration is ITypedRegistration<TInterface2, TImplementation> interface2Registration)
-                    interface3Registration.OnCreate(action);
+                interface2Registration.OnCreate(action);
-                else if (registration is ITypedRegistration<TInterface2, TImplementation> interface2Registration)
+            else if (registration is ITypedRegistration<TInterface1, TImplementation> interface1Registration)
-                    interface2Registration.OnCreate(action);
+                interface1Registration.OnCreate(action);
-                else if (registration is ITypedRegistration<TInterface1, TImplementation> interface1Registration)
-                    interface1Registration.OnCreate(action);
-            }
-
-            return this;
         }
+
+        return this;
     }
+}
 
+/// <summary>
+/// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
+/// </summary>
+/// <typeparam name="TInterface1">The first interface</typeparam>
+/// <typeparam name="TInterface2">The second interface</typeparam>
+/// <typeparam name="TInterface3">The third interface</typeparam>
+/// <typeparam name="TInterface4">The fourth interface</typeparam>
+/// <typeparam name="TInterface5">The fifth interface</typeparam>
+/// <typeparam name="TImplementation">The implementation</typeparam>
+internal class MultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation> : MultipleRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation> where TImplementation : TInterface5, TInterface4, TInterface3, TInterface2, TInterface1
+{
     /// <summary>
     /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
     /// </summary>
-    /// <typeparam name="TInterface1">The first interface</typeparam>
+    /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-    /// <typeparam name="TInterface2">The second interface</typeparam>
+    /// <param name="interfaceType2">The <see cref="Type"/> of the second interface</param>
-    /// <typeparam name="TInterface3">The third interface</typeparam>
+    /// <param name="interfaceType3">The <see cref="Type"/> of the third interface</param>
-    /// <typeparam name="TInterface4">The fourth interface</typeparam>
+    /// <param name="interfaceType4">The <see cref="Type"/> of the fourth interface</param>
-    /// <typeparam name="TInterface5">The fifth interface</typeparam>
+    /// <param name="interfaceType5">The <see cref="Type"/> of the fifth interface</param>
-    /// <typeparam name="TImplementation">The implementation</typeparam>
+    /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-    internal class MultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation> : MultipleRegistration<TInterface1, TImplementation>, IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation> where TImplementation : TInterface5, TInterface4, TInterface3, TInterface2, TInterface1
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="MultipleRegistration{TInterface1,TInterface2}"/></param>
+    /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
+    public MultipleRegistration(Type interfaceType1, Type interfaceType2, Type interfaceType3, Type interfaceType4, Type interfaceType5, Type implementationType, Lifestyle lifestyle, IocContainer container)
+        : base(interfaceType1, implementationType, lifestyle, container)
     {
-        /// <summary>
+        Registrations = new List<IRegistration>
-        /// An <see cref="IRegistration"/> to register multiple interfaces for on implementation type
-        /// </summary>
-        /// <param name="interfaceType1">The <see cref="Type"/> of the first interface</param>
-        /// <param name="interfaceType2">The <see cref="Type"/> of the second interface</param>
-        /// <param name="interfaceType3">The <see cref="Type"/> of the third interface</param>
-        /// <param name="interfaceType4">The <see cref="Type"/> of the fourth interface</param>
-        /// <param name="interfaceType5">The <see cref="Type"/> of the fifth interface</param>
-        /// <param name="implementationType">The <see cref="Type"/> of the implementation</param>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="MultipleRegistration{TInterface1,TInterface2}"/></param>
-        /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-        public MultipleRegistration(Type interfaceType1, Type interfaceType2, Type interfaceType3, Type interfaceType4, Type interfaceType5, Type implementationType, Lifestyle lifestyle, IocContainer container)
-            : base(interfaceType1, implementationType, lifestyle, container)
         {
-            Registrations = new List<IRegistration>
+            new TypedRegistration<TInterface1, TImplementation>(interfaceType1, implementationType, lifestyle, container),
-            {
+            new TypedRegistration<TInterface2, TImplementation>(interfaceType2, implementationType, lifestyle, container),
-                new TypedRegistration<TInterface1, TImplementation>(interfaceType1, implementationType, lifestyle, container),
+            new TypedRegistration<TInterface3, TImplementation>(interfaceType3, implementationType, lifestyle, container),
-                new TypedRegistration<TInterface2, TImplementation>(interfaceType2, implementationType, lifestyle, container),
+            new TypedRegistration<TInterface4, TImplementation>(interfaceType4, implementationType, lifestyle, container),
-                new TypedRegistration<TInterface3, TImplementation>(interfaceType3, implementationType, lifestyle, container),
+            new TypedRegistration<TInterface5, TImplementation>(interfaceType5, implementationType, lifestyle, container)
-                new TypedRegistration<TInterface4, TImplementation>(interfaceType4, implementationType, lifestyle, container),
+        };
-                new TypedRegistration<TInterface5, TImplementation>(interfaceType5, implementationType, lifestyle, container)
+    }
-            };
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
+    /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
-        /// </summary>
+    /// </summary>
-        /// <param name="action">The <see cref="Action{T}"/></param>
+    /// <param name="action">The <see cref="Action{T}"/></param>
-        /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
+    /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
-        public override ITypedRegistration<TInterface1, TImplementation> OnCreate(Action<TImplementation?> action)
+    public override ITypedRegistration<TInterface1, TImplementation> OnCreate(Action<TImplementation?> action)
+    {
+        foreach (IRegistration registration in Registrations)
         {
-            foreach (IRegistration registration in Registrations)
+            if (registration is ITypedRegistration<TInterface5, TImplementation> interface5Registration)
-            {
+                interface5Registration.OnCreate(action);
-                if (registration is ITypedRegistration<TInterface5, TImplementation> interface5Registration)
+            else if (registration is ITypedRegistration<TInterface4, TImplementation> interface4Registration)
-                    interface5Registration.OnCreate(action);
+                interface4Registration.OnCreate(action);
-                else if (registration is ITypedRegistration<TInterface4, TImplementation> interface4Registration)
+            else if (registration is ITypedRegistration<TInterface3, TImplementation> interface3Registration)
-                    interface4Registration.OnCreate(action);
+                interface3Registration.OnCreate(action);
-                else if (registration is ITypedRegistration<TInterface3, TImplementation> interface3Registration)
+            else if (registration is ITypedRegistration<TInterface2, TImplementation> interface2Registration)
-                    interface3Registration.OnCreate(action);
+                interface2Registration.OnCreate(action);
-                else if (registration is ITypedRegistration<TInterface2, TImplementation> interface2Registration)
+            else if (registration is ITypedRegistration<TInterface1, TImplementation> interface1Registration)
-                    interface2Registration.OnCreate(action);
+                interface1Registration.OnCreate(action);
-                else if (registration is ITypedRegistration<TInterface1, TImplementation> interface1Registration)
-                    interface1Registration.OnCreate(action);
-            }
-
-            return this;
         }
+
+        return this;
     }
 }

LightweightIocContainer/Registrations/MultitonRegistration.cs

@@ -8,52 +8,51 @@ using LightweightIocContainer.Exceptions;
 using LightweightIocContainer.Interfaces;
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Registrations
+namespace LightweightIocContainer.Registrations;
+
+/// <summary>
+/// The registration that is used to register a multiton
+/// </summary>
+/// <typeparam name="TInterface">The registered interface</typeparam>
+/// <typeparam name="TImplementation">The registered implementation</typeparam>
+internal class MultitonRegistration<TInterface, TImplementation> : TypedRegistration<TInterface, TImplementation>, IMultitonRegistration<TInterface, TImplementation> where TImplementation : TInterface
 {
     /// <summary>
     /// The registration that is used to register a multiton
     /// </summary>
-    /// <typeparam name="TInterface">The registered interface</typeparam>
+    /// <param name="interfaceType">The <see cref="Type"/> of the Interface</param>
-    /// <typeparam name="TImplementation">The registered implementation</typeparam>
+    /// <param name="implementationType">The <see cref="Type"/> of the Implementation</param>
-    internal class MultitonRegistration<TInterface, TImplementation> : TypedRegistration<TInterface, TImplementation>, IMultitonRegistration<TInterface, TImplementation> where TImplementation : TInterface
+    /// <param name="scope">The <see cref="Type"/> of the Multiton Scope</param>
+    /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
+    public MultitonRegistration(Type interfaceType, Type implementationType, Type scope, IocContainer container)
+        : base(interfaceType, implementationType, Lifestyle.Multiton, container) =>
+        Scope = scope;
+
+    /// <summary>
+    /// The <see cref="Type"/> of the multiton scope
+    /// </summary>
+    public Type Scope { get; }
+
+    /// <summary>
+    /// Validate the <see cref="RegistrationBase.Factory"/>
+    /// </summary>
+    protected override void ValidateFactory()
     {
-        /// <summary>
+        if (Factory == null)
-        /// The registration that is used to register a multiton
+            return;
-        /// </summary>
+            
-        /// <param name="interfaceType">The <see cref="Type"/> of the Interface</param>
+        if (Factory.CreateMethods.Any(c => c.GetParameters().Length == 0))
-        /// <param name="implementationType">The <see cref="Type"/> of the Implementation</param>
+            throw new InvalidFactoryRegistrationException($"Create methods without parameters are not valid for multitons (Type: {InterfaceType}).");
-        /// <param name="scope">The <see cref="Type"/> of the Multiton Scope</param>
+            
-        /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
+        if (Factory.CreateMethods.Any(c => c.GetParameters()[0].ParameterType != Scope))
-        public MultitonRegistration(Type interfaceType, Type implementationType, Type scope, IocContainer container)
+            throw new InvalidFactoryRegistrationException($"Create methods without scope type ({Scope}) as first parameter are not valid for multitons (Type: {InterfaceType}).");
-            : base(interfaceType, implementationType, Lifestyle.Multiton, container) =>
+            
-            Scope = scope;
+        base.ValidateFactory();
-
-        /// <summary>
-        /// The <see cref="Type"/> of the multiton scope
-        /// </summary>
-        public Type Scope { get; }
-
-        /// <summary>
-        /// Validate the <see cref="RegistrationBase.Factory"/>
-        /// </summary>
-        protected override void ValidateFactory()
-        {
-            if (Factory == null)
-                return;
-            
-            if (Factory.CreateMethods.Any(c => c.GetParameters().Length == 0))
-                throw new InvalidFactoryRegistrationException($"Create methods without parameters are not valid for multitons (Type: {InterfaceType}).");
-            
-            if (Factory.CreateMethods.Any(c => c.GetParameters()[0].ParameterType != Scope))
-                throw new InvalidFactoryRegistrationException($"Create methods without scope type ({Scope}) as first parameter are not valid for multitons (Type: {InterfaceType}).");
-            
-            base.ValidateFactory();
-        }
-
-        public override bool Equals(object? obj) => obj is MultitonRegistration<TInterface, TImplementation> multitonRegistration && 
-                                                    base.Equals(obj) &&
-                                                    Scope == multitonRegistration.Scope;
-
-        public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), Scope);
     }
+
+    public override bool Equals(object? obj) => obj is MultitonRegistration<TInterface, TImplementation> multitonRegistration && 
+                                                base.Equals(obj) &&
+                                                Scope == multitonRegistration.Scope;
+
+    public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), Scope);
 }

LightweightIocContainer/Registrations/OpenGenericRegistration.cs

@@ -7,47 +7,46 @@ using LightweightIocContainer.Exceptions;
 using LightweightIocContainer.Interfaces;
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Registrations
+namespace LightweightIocContainer.Registrations;
+
+/// <summary>
+/// <see cref="IRegistration"/> for open generic types
+/// </summary>
+internal class OpenGenericRegistration : RegistrationBase, IOpenGenericRegistration
 {
     /// <summary>
     /// <see cref="IRegistration"/> for open generic types
     /// </summary>
-    internal class OpenGenericRegistration : RegistrationBase, IOpenGenericRegistration
+    /// <param name="interfaceType">The <see cref="Type"/> of the interface</param>
+    /// <param name="implementationType">The <see cref="Type"/> of the implementation type</param>
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="IOpenGenericRegistration"/></param>
+    /// <param name="iocContainer">The current instance of the <see cref="IIocContainer"/></param>
+    public OpenGenericRegistration(Type interfaceType, Type implementationType, Lifestyle lifestyle, IocContainer iocContainer)
+        : base(interfaceType, lifestyle, iocContainer) =>
+        ImplementationType = implementationType;
+
+    /// <summary>
+    /// The <see cref="Type"/> that implements the <see cref="IRegistration.InterfaceType"/> that is registered with this <see cref="IOpenGenericRegistration"/>
+    /// </summary>
+    public Type ImplementationType { get; }
+
+    /// <summary>
+    /// Validate this <see cref="OpenGenericRegistration"/>
+    /// </summary>
+    public override void Validate()
     {
-        /// <summary>
+        if (!InterfaceType.ContainsGenericParameters)
-        /// <see cref="IRegistration"/> for open generic types
+            throw new InvalidRegistrationException("This function can only be used to register open generic types.");
-        /// </summary>
+            
-        /// <param name="interfaceType">The <see cref="Type"/> of the interface</param>
+        if (Lifestyle == Lifestyle.Multiton)
-        /// <param name="implementationType">The <see cref="Type"/> of the implementation type</param>
+            throw new InvalidRegistrationException("Can't register a multiton with open generic registration."); //TODO: Is there any need to register multitons with open generics?
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="IOpenGenericRegistration"/></param>
+            
-        /// <param name="iocContainer">The current instance of the <see cref="IIocContainer"/></param>
+        base.Validate();
-        public OpenGenericRegistration(Type interfaceType, Type implementationType, Lifestyle lifestyle, IocContainer iocContainer)
-            : base(interfaceType, lifestyle, iocContainer) =>
-            ImplementationType = implementationType;
-
-        /// <summary>
-        /// The <see cref="Type"/> that implements the <see cref="IRegistration.InterfaceType"/> that is registered with this <see cref="IOpenGenericRegistration"/>
-        /// </summary>
-        public Type ImplementationType { get; }
-
-        /// <summary>
-        /// Validate this <see cref="OpenGenericRegistration"/>
-        /// </summary>
-        public override void Validate()
-        {
-            if (!InterfaceType.ContainsGenericParameters)
-                throw new InvalidRegistrationException("This function can only be used to register open generic types.");
-            
-            if (Lifestyle == Lifestyle.Multiton)
-                throw new InvalidRegistrationException("Can't register a multiton with open generic registration."); //TODO: Is there any need to register multitons with open generics?
-            
-            base.Validate();
-        }
-        
-        public override bool Equals(object? obj) => obj is OpenGenericRegistration openGenericRegistration &&
-                                                    base.Equals(obj) &&
-                                                    ImplementationType == openGenericRegistration.ImplementationType;
-
-        public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), ImplementationType);
     }
+        
+    public override bool Equals(object? obj) => obj is OpenGenericRegistration openGenericRegistration &&
+                                                base.Equals(obj) &&
+                                                ImplementationType == openGenericRegistration.ImplementationType;
+
+    public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), ImplementationType);
 }

LightweightIocContainer/Registrations/RegistrationBase.cs

@@ -12,236 +12,235 @@ using LightweightIocContainer.Interfaces.Registrations;
 using LightweightIocContainer.Interfaces.Registrations.Fluent;
 using LightweightIocContainer.ResolvePlaceholders;
 
-namespace LightweightIocContainer.Registrations
+namespace LightweightIocContainer.Registrations;
+
+/// <summary>
+/// The <see cref="RegistrationBase"/> that is used to register an Interface
+/// </summary>
+internal abstract class RegistrationBase : IRegistrationBase, IWithFactoryInternal, IWithParametersInternal, ILifestyleProvider, IWithDisposeStrategyInternal, IInternalValidationProvider
 {
+    private readonly IocContainer _container;
+
     /// <summary>
     /// The <see cref="RegistrationBase"/> that is used to register an Interface
     /// </summary>
-    internal abstract class RegistrationBase : IRegistrationBase, IWithFactoryInternal, IWithParametersInternal, ILifestyleProvider, IWithDisposeStrategyInternal, IInternalValidationProvider
+    /// <param name="interfaceType">The <see cref="Type"/> of the Interface</param>
+    /// <param name="lifestyle">The <see cref="LightweightIocContainer.Lifestyle"/> of the registration</param>
+    /// <param name="container">The current instance of the <see cref="IocContainer"/></param>
+    protected RegistrationBase(Type interfaceType, Lifestyle lifestyle, IocContainer container)
     {
-        private readonly IocContainer _container;
+        InterfaceType = interfaceType;
-
+        Lifestyle = lifestyle;
-        /// <summary>
+        _container = container;
-        /// The <see cref="RegistrationBase"/> that is used to register an Interface
+    }
-        /// </summary>
-        /// <param name="interfaceType">The <see cref="Type"/> of the Interface</param>
-        /// <param name="lifestyle">The <see cref="LightweightIocContainer.Lifestyle"/> of the registration</param>
-        /// <param name="container">The current instance of the <see cref="IocContainer"/></param>
-        protected RegistrationBase(Type interfaceType, Lifestyle lifestyle, IocContainer container)
-        {
-            InterfaceType = interfaceType;
-            Lifestyle = lifestyle;
-            _container = container;
-        }
 
-        /// <summary>
+    /// <summary>
-        /// The <see cref="Type"/> of the Interface that is registered with this <see cref="RegistrationBase"/>
+    /// The <see cref="Type"/> of the Interface that is registered with this <see cref="RegistrationBase"/>
-        /// </summary>
+    /// </summary>
-        public Type InterfaceType { get; }
+    public Type InterfaceType { get; }
-
-        /// <summary>
-        /// The <see cref="LightweightIocContainer.Lifestyle"/> of Instances that are created with this <see cref="RegistrationBase"/>
-        /// </summary>
-        public Lifestyle Lifestyle { get; }
-        
-        /// <summary>
-        /// The <see cref="LightweightIocContainer.DisposeStrategy"/> of singletons/multitons that implement <see cref="IDisposable"/> and are created with this <see cref="RegistrationBase"/>
-        /// </summary>
-        public DisposeStrategy DisposeStrategy { get; private set; }
-
-        /// <summary>
-        /// An <see cref="Array"/> of parameters that are used to <see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
-        /// <para>Can be set in the <see cref="IIocInstaller"/> by calling <see cref="WithParameters(object[])"/></para>
-        /// </summary>
-        public object[]? Parameters { get; private set; }
-        
-        /// <summary>
-        /// The Factory added with the <see cref="WithFactory{TFactory}"/> method
-        /// </summary>
-        public ITypedFactory? Factory { get; private set; }
-
-        /// <summary>
-        /// Pass parameters that will be used to <see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
-        /// <para>Parameters set with this method are always inserted at the beginning of the argument list if more parameters are given when resolving</para>
-        /// </summary>
-        /// <param name="parameters">The parameters</param>
-        /// <returns>The current instance of this <see cref="IRegistration"/></returns>
-        /// <exception cref="InvalidRegistrationException"><see cref="Parameters"/> are already set or no parameters given</exception>
-        public virtual IRegistrationBase WithParameters(params object[] parameters)
-        {
-            if (Parameters != null)
-                throw new InvalidRegistrationException($"Don't use `WithParameters()` method twice (Type: {InterfaceType}).");
 
-            if (parameters == null || !parameters.Any())
+    /// <summary>
-                throw new InvalidRegistrationException($"No parameters given to `WithParameters()` method (Type: {InterfaceType}).");
+    /// The <see cref="LightweightIocContainer.Lifestyle"/> of Instances that are created with this <see cref="RegistrationBase"/>
+    /// </summary>
+    public Lifestyle Lifestyle { get; }
         
-            Parameters = parameters;
+    /// <summary>
-            return this;
+    /// The <see cref="LightweightIocContainer.DisposeStrategy"/> of singletons/multitons that implement <see cref="IDisposable"/> and are created with this <see cref="RegistrationBase"/>
-        }
+    /// </summary>
+    public DisposeStrategy DisposeStrategy { get; private set; }
 
-        /// <summary>
+    /// <summary>
-        /// Pass parameters that will be used to<see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
+    /// An <see cref="Array"/> of parameters that are used to <see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
-        /// <para>Parameters set with this method are inserted at the position in the argument list that is passed with the parameter if more parameters are given when resolving</para>
+    /// <para>Can be set in the <see cref="IIocInstaller"/> by calling <see cref="WithParameters(object[])"/></para>
-        /// </summary>
+    /// </summary>
-        /// <param name="parameters">The parameters with their position</param>
+    public object[]? Parameters { get; private set; }
-        /// <returns>The current instance of this <see cref="IRegistration"/></returns>
-        /// <exception cref="InvalidRegistrationException"><see cref="Parameters"/> are already set or no parameters given</exception>
-        public virtual IRegistrationBase WithParameters(params (int index, object parameter)[] parameters)
-        {
-            if (Parameters != null)
-                throw new InvalidRegistrationException($"Don't use `WithParameters()` method twice (Type: {InterfaceType}).");
         
-            if (parameters == null || !parameters.Any())
+    /// <summary>
-                throw new InvalidRegistrationException($"No parameters given to `WithParameters()` method (Type: {InterfaceType}).");
+    /// The Factory added with the <see cref="WithFactory{TFactory}"/> method
+    /// </summary>
+    public ITypedFactory? Factory { get; private set; }
 
-            int lastIndex = parameters.Max(p => p.index);
+    /// <summary>
-            Parameters = new object[lastIndex + 1];
+    /// Pass parameters that will be used to <see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
+    /// <para>Parameters set with this method are always inserted at the beginning of the argument list if more parameters are given when resolving</para>
+    /// </summary>
+    /// <param name="parameters">The parameters</param>
+    /// <returns>The current instance of this <see cref="IRegistration"/></returns>
+    /// <exception cref="InvalidRegistrationException"><see cref="Parameters"/> are already set or no parameters given</exception>
+    public virtual IRegistrationBase WithParameters(params object[] parameters)
+    {
+        if (Parameters != null)
+            throw new InvalidRegistrationException($"Don't use `WithParameters()` method twice (Type: {InterfaceType}).");
 
-            for (int i = 0; i < Parameters.Length; i++)
+        if (parameters == null || !parameters.Any())
-            {
+            throw new InvalidRegistrationException($"No parameters given to `WithParameters()` method (Type: {InterfaceType}).");
-                if (parameters.Any(p => p.index == i))
-                    Parameters[i] = parameters.First(p => p.index == i).parameter;
-                else
-                    Parameters[i] = new InternalResolvePlaceholder();
-            }
 
-            return this;
+        Parameters = parameters;
-        }
+        return this;
+    }
 
-        /// <summary>
+    /// <summary>
-        /// Register an abstract typed factory for the <see cref="IRegistrationBase"/> 
+    /// Pass parameters that will be used to<see cref="IocContainer.Resolve{T}()"/> an instance of this <see cref="IRegistration.InterfaceType"/>
-        /// </summary>
+    /// <para>Parameters set with this method are inserted at the position in the argument list that is passed with the parameter if more parameters are given when resolving</para>
-        /// <typeparam name="TFactory">The type of the abstract typed factory</typeparam>
+    /// </summary>
-        /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
+    /// <param name="parameters">The parameters with their position</param>
-        public IRegistrationBase WithFactory<TFactory>()
+    /// <returns>The current instance of this <see cref="IRegistration"/></returns>
-        {
+    /// <exception cref="InvalidRegistrationException"><see cref="Parameters"/> are already set or no parameters given</exception>
-            TypedFactory<TFactory> factory = new(_container);
+    public virtual IRegistrationBase WithParameters(params (int index, object parameter)[] parameters)
-            Factory = factory;
+    {
+        if (Parameters != null)
+            throw new InvalidRegistrationException($"Don't use `WithParameters()` method twice (Type: {InterfaceType}).");
 
-            _container.RegisterFactory(factory);
+        if (parameters == null || !parameters.Any())
+            throw new InvalidRegistrationException($"No parameters given to `WithParameters()` method (Type: {InterfaceType}).");
 
-            return this;
+        int lastIndex = parameters.Max(p => p.index);
-        }
+        Parameters = new object[lastIndex + 1];
 
-        /// <summary>
+        for (int i = 0; i < Parameters.Length; i++)
-        /// Register a custom implemented factory for the <see cref="IRegistrationBase"/>
-        /// </summary>
-        /// <typeparam name="TFactoryInterface">The type of the interface for the custom factory</typeparam>
-        /// <typeparam name="TFactoryImplementation">The type of the implementation for the custom factory</typeparam>
-        /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
-        public IRegistrationBase WithFactory<TFactoryInterface, TFactoryImplementation>() where TFactoryImplementation : TFactoryInterface
         {
-            Factory = new CustomTypedFactory<TFactoryInterface>();
+            if (parameters.Any(p => p.index == i))
-            _container.Register(r => r.Add<TFactoryInterface, TFactoryImplementation>());
+                Parameters[i] = parameters.First(p => p.index == i).parameter;
-
+            else
-            return this;
+                Parameters[i] = new InternalResolvePlaceholder();
         }
 
-        /// <summary>
+        return this;
-        /// Add a <see cref="DisposeStrategy"/> for the <see cref="IRegistrationBase"/>
+    }
-        /// </summary>
-        /// <param name="disposeStrategy">The <see cref="DisposeStrategy"/></param>
-        /// <returns>The current instance of this <see cref="RegistrationBase"/></returns>
-        public IRegistrationBase WithDisposeStrategy(DisposeStrategy disposeStrategy)
-        {
-            DisposeStrategy = disposeStrategy;
-            return this;
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Validate this <see cref="RegistrationBase"/>
+    /// Register an abstract typed factory for the <see cref="IRegistrationBase"/> 
-        /// </summary>
+    /// </summary>
-        public virtual void Validate()
+    /// <typeparam name="TFactory">The type of the abstract typed factory</typeparam>
-        {
+    /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
-            ValidateMultiton();
+    public IRegistrationBase WithFactory<TFactory>()
-            ValidateFactory();
+    {
-            ValidateDisposeStrategy();
+        TypedFactory<TFactory> factory = new(_container);
-        }
+        Factory = factory;
             
-        /// <summary>
+        _container.RegisterFactory(factory);
-        /// Validate that no registration that isn't derived from <see cref="IMultitonRegistration"/> has <see cref="LightweightIocContainer.Lifestyle.Multiton"/>
-        /// </summary>
-        /// <exception cref="InvalidRegistrationException"></exception>
-        private void ValidateMultiton()
-        {
-            //don't allow lifestyle.multiton without iMultitonRegistration
-            if (Lifestyle == Lifestyle.Multiton && this is not IMultitonRegistration)
-                throw new InvalidRegistrationException("Can't register a type as Lifestyle.Multiton without a scope (Registration is not of type IMultitonRegistration).");
-        }
             
-        /// <summary>
+        return this;
-        /// Validate the <see cref="Factory"/>
+    }
-        /// </summary>
-        /// <exception cref="InvalidFactoryRegistrationException">No create method that can create the <see cref="InterfaceType"/></exception>
-        protected virtual void ValidateFactory()
-        {
-            if (Factory == null)
-                return;
 
-            if (Factory.CreateMethods.All(c => c.ReturnType != InterfaceType))
+    /// <summary>
-                throw new InvalidFactoryRegistrationException($"No create method that can create {InterfaceType}.");
+    /// Register a custom implemented factory for the <see cref="IRegistrationBase"/>
-        }
+    /// </summary>
+    /// <typeparam name="TFactoryInterface">The type of the interface for the custom factory</typeparam>
+    /// <typeparam name="TFactoryImplementation">The type of the implementation for the custom factory</typeparam>
+    /// <returns>The current instance of this <see cref="IRegistrationBase"/></returns>
+    public IRegistrationBase WithFactory<TFactoryInterface, TFactoryImplementation>() where TFactoryImplementation : TFactoryInterface
+    {
+        Factory = new CustomTypedFactory<TFactoryInterface>();
+        _container.Register(r => r.Add<TFactoryInterface, TFactoryImplementation>());
+
+        return this;
+    }
+        
+    /// <summary>
+    /// Add a <see cref="DisposeStrategy"/> for the <see cref="IRegistrationBase"/>
+    /// </summary>
+    /// <param name="disposeStrategy">The <see cref="DisposeStrategy"/></param>
+    /// <returns>The current instance of this <see cref="RegistrationBase"/></returns>
+    public IRegistrationBase WithDisposeStrategy(DisposeStrategy disposeStrategy)
+    {
+        DisposeStrategy = disposeStrategy;
+        return this;
+    }
+        
+    /// <summary>
+    /// Validate this <see cref="RegistrationBase"/>
+    /// </summary>
+    public virtual void Validate()
+    {
+        ValidateMultiton();
+        ValidateFactory();
+        ValidateDisposeStrategy();
+    }
+
+    /// <summary>
+    /// Validate that no registration that isn't derived from <see cref="IMultitonRegistration"/> has <see cref="LightweightIocContainer.Lifestyle.Multiton"/>
+    /// </summary>
+    /// <exception cref="InvalidRegistrationException"></exception>
+    private void ValidateMultiton()
+    {
+        //don't allow lifestyle.multiton without iMultitonRegistration
+        if (Lifestyle == Lifestyle.Multiton && this is not IMultitonRegistration)
+            throw new InvalidRegistrationException("Can't register a type as Lifestyle.Multiton without a scope (Registration is not of type IMultitonRegistration).");
+    }
+
+    /// <summary>
+    /// Validate the <see cref="Factory"/>
+    /// </summary>
+    /// <exception cref="InvalidFactoryRegistrationException">No create method that can create the <see cref="InterfaceType"/></exception>
+    protected virtual void ValidateFactory()
+    {
+        if (Factory == null)
+            return;
             
-        /// <summary>
+        if (Factory.CreateMethods.All(c => c.ReturnType != InterfaceType))
-        /// Validate the <see cref="DisposeStrategy"/> for the <see cref="InterfaceType"/> and <see cref="Lifestyle"/>
+            throw new InvalidFactoryRegistrationException($"No create method that can create {InterfaceType}.");
-        /// </summary>
+    }
-        protected virtual void ValidateDisposeStrategy() => ValidateDisposeStrategy(InterfaceType);
+        
-
+    /// <summary>
-        /// <summary>
+    /// Validate the <see cref="DisposeStrategy"/> for the <see cref="InterfaceType"/> and <see cref="Lifestyle"/>
-        /// Validate the <see cref="DisposeStrategy"/> for the given <see cref="Type"/> and <see cref="Lifestyle"/>
+    /// </summary>
-        /// </summary>
+    protected virtual void ValidateDisposeStrategy() => ValidateDisposeStrategy(InterfaceType);
-        /// <param name="type">The given <see cref="Type"/></param>
+
-        /// <exception cref="InvalidDisposeStrategyException">Dispose strategy is invalid for this <see cref="InterfaceType"/> and <see cref="Lifestyle"/></exception>
+    /// <summary>
-        protected void ValidateDisposeStrategy(Type type)
+    /// Validate the <see cref="DisposeStrategy"/> for the given <see cref="Type"/> and <see cref="Lifestyle"/>
+    /// </summary>
+    /// <param name="type">The given <see cref="Type"/></param>
+    /// <exception cref="InvalidDisposeStrategyException">Dispose strategy is invalid for this <see cref="InterfaceType"/> and <see cref="Lifestyle"/></exception>
+    protected void ValidateDisposeStrategy(Type type)
+    {
+        if (Lifestyle == Lifestyle.Transient)
         {
-            if (Lifestyle == Lifestyle.Transient)
+            if (DisposeStrategy != DisposeStrategy.None)
+                throw new InvalidDisposeStrategyException(DisposeStrategy, type, Lifestyle);
+        }
+        else
+        {
+            if (type.IsAssignableTo(typeof(IDisposable)))
             {
-                if (DisposeStrategy != DisposeStrategy.None)
+                if (DisposeStrategy == DisposeStrategy.None)
                     throw new InvalidDisposeStrategyException(DisposeStrategy, type, Lifestyle);
             }
             else
             {
-                if (type.IsAssignableTo(typeof(IDisposable)))
+                if (DisposeStrategy != DisposeStrategy.None)
-                {
+                    throw new InvalidDisposeStrategyException(DisposeStrategy, type, Lifestyle);
-                    if (DisposeStrategy == DisposeStrategy.None)
-                        throw new InvalidDisposeStrategyException(DisposeStrategy, type, Lifestyle);
-                }
-                else
-                {
-                    if (DisposeStrategy != DisposeStrategy.None)
-                        throw new InvalidDisposeStrategyException(DisposeStrategy, type, Lifestyle);
-                }
             }
         }
+    }
 
-        public override bool Equals(object? obj)
+    public override bool Equals(object? obj)
-        {
+    {
-            if (obj is not RegistrationBase registrationBase)
+        if (obj is not RegistrationBase registrationBase)
-                return false;
+            return false;
-
-            if (Parameters == null && registrationBase.Parameters != null)
-                return false;
 
-            if (Parameters != null && registrationBase.Parameters == null)
+        if (Parameters == null && registrationBase.Parameters != null)
-                return false;
+            return false;
 
-            if (Parameters?.Length != registrationBase.Parameters?.Length)
+        if (Parameters != null && registrationBase.Parameters == null)
-                return false;
+            return false;
 
-            if (Factory == null && registrationBase.Factory != null)
+        if (Parameters?.Length != registrationBase.Parameters?.Length)
-                return false;
+            return false;
             
-            if (Factory != null && registrationBase.Factory == null)
+        if (Factory == null && registrationBase.Factory != null)
-                return false;
+            return false;
 
-            if (Factory?.CreateMethods.Count != registrationBase.Factory?.CreateMethods.Count)
+        if (Factory != null && registrationBase.Factory == null)
-                return false;
+            return false;
 
-            return InterfaceType == registrationBase.InterfaceType &&
+        if (Factory?.CreateMethods.Count != registrationBase.Factory?.CreateMethods.Count)
-                   Lifestyle == registrationBase.Lifestyle &&
+            return false;
-                   DisposeStrategy == registrationBase.DisposeStrategy;
-        }
             
-        public override int GetHashCode() => HashCode.Combine(InterfaceType, (int) Lifestyle);
+        return InterfaceType == registrationBase.InterfaceType &&
+               Lifestyle == registrationBase.Lifestyle &&
+               DisposeStrategy == registrationBase.DisposeStrategy;
     }
+        
+    public override int GetHashCode() => HashCode.Combine(InterfaceType, (int) Lifestyle);
 }

LightweightIocContainer/Registrations/RegistrationFactory.cs

@@ -7,121 +7,120 @@ using LightweightIocContainer.Interfaces.Factories;
 using LightweightIocContainer.Interfaces.Installers;
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Registrations
+namespace LightweightIocContainer.Registrations;
+
+/// <summary>
+/// A factory to register interfaces and factories in an <see cref="IIocInstaller"/> and create the needed <see cref="IRegistration"/>s
+/// </summary>
+internal class RegistrationFactory
 {
-    /// <summary>
+    private readonly IocContainer _iocContainer;
-    /// A factory to register interfaces and factories in an <see cref="IIocInstaller"/> and create the needed <see cref="IRegistration"/>s
-    /// </summary>
-    internal class RegistrationFactory
-    {
-        private readonly IocContainer _iocContainer;
 
-        internal RegistrationFactory(IocContainer container) => _iocContainer = container;
+    internal RegistrationFactory(IocContainer container) => _iocContainer = container;
 
-        /// <summary>
+    /// <summary>
-        /// Register an Interface with a Type that implements it and create a <see cref="ITypedRegistration{TInterface,TImplementation}"/>
+    /// Register an Interface with a Type that implements it and create a <see cref="ITypedRegistration{TInterface,TImplementation}"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TInterface">The Interface to register</typeparam>
+    /// <typeparam name="TInterface">The Interface to register</typeparam>
-        /// <typeparam name="TImplementation">The Type that implements the interface</typeparam>
+    /// <typeparam name="TImplementation">The Type that implements the interface</typeparam>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="ITypedRegistration{TInterface,TImplementation}"/></param>
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="ITypedRegistration{TInterface,TImplementation}"/></param>
-        /// <returns>A new created <see cref="ITypedRegistration{TInterface,TImplementation}"/> with the given parameters</returns>
+    /// <returns>A new created <see cref="ITypedRegistration{TInterface,TImplementation}"/> with the given parameters</returns>
-        public ITypedRegistration<TInterface, TImplementation> Register<TInterface, TImplementation>(Lifestyle lifestyle) where TImplementation : TInterface => 
+    public ITypedRegistration<TInterface, TImplementation> Register<TInterface, TImplementation>(Lifestyle lifestyle) where TImplementation : TInterface => 
-            new TypedRegistration<TInterface, TImplementation>(typeof(TInterface), typeof(TImplementation), lifestyle, _iocContainer);
+        new TypedRegistration<TInterface, TImplementation>(typeof(TInterface), typeof(TImplementation), lifestyle, _iocContainer);
 
-        /// <summary>
+    /// <summary>
-        /// Register an open generic Interface with an open generic Type that implements it and create a <see cref="IOpenGenericRegistration"/>
+    /// Register an open generic Interface with an open generic Type that implements it and create a <see cref="IOpenGenericRegistration"/>
-        /// </summary>
+    /// </summary>
-        /// <param name="tInterface">The open generic Interface to register</param>
+    /// <param name="tInterface">The open generic Interface to register</param>
-        /// <param name="tImplementation">The open generic Type that implements the interface</param>
+    /// <param name="tImplementation">The open generic Type that implements the interface</param>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="IOpenGenericRegistration"/></param>
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="IOpenGenericRegistration"/></param>
-        /// <returns>The created <see cref="IOpenGenericRegistration"/></returns>
+    /// <returns>The created <see cref="IOpenGenericRegistration"/></returns>
-        public IOpenGenericRegistration Register(Type tInterface, Type tImplementation, Lifestyle lifestyle) =>
+    public IOpenGenericRegistration Register(Type tInterface, Type tImplementation, Lifestyle lifestyle) =>
-            new OpenGenericRegistration(tInterface, tImplementation, lifestyle, _iocContainer);
+        new OpenGenericRegistration(tInterface, tImplementation, lifestyle, _iocContainer);
 
-        /// <summary>
+    /// <summary>
-        /// Register multiple interfaces for a <see cref="Type"/> that implements them and create a <see cref="IMultipleRegistration{TInterface1,TInterface2}"/>
+    /// Register multiple interfaces for a <see cref="Type"/> that implements them and create a <see cref="IMultipleRegistration{TInterface1,TInterface2}"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TInterface1">The base interface to register</typeparam>
+    /// <typeparam name="TInterface1">The base interface to register</typeparam>
-        /// <typeparam name="TInterface2">A second interface to register</typeparam>
+    /// <typeparam name="TInterface2">A second interface to register</typeparam>
-        /// <typeparam name="TImplementation">The <see cref="Type"/> that implements both interfaces</typeparam>
+    /// <typeparam name="TImplementation">The <see cref="Type"/> that implements both interfaces</typeparam>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="IRegistrationBase"/></param>
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="IRegistrationBase"/></param>
-        /// <returns>The created <see cref="IMultipleRegistration{TInterface1,TInterface2}"/></returns>
+    /// <returns>The created <see cref="IMultipleRegistration{TInterface1,TInterface2}"/></returns>
-        public IMultipleRegistration<TInterface1, TInterface2, TImplementation> Register<TInterface1, TInterface2, TImplementation>(Lifestyle lifestyle) where TImplementation : TInterface1, TInterface2 => 
+    public IMultipleRegistration<TInterface1, TInterface2, TImplementation> Register<TInterface1, TInterface2, TImplementation>(Lifestyle lifestyle) where TImplementation : TInterface1, TInterface2 => 
-            new MultipleRegistration<TInterface1, TInterface2, TImplementation>(typeof(TInterface1), typeof(TInterface2), typeof(TImplementation), lifestyle, _iocContainer);
+        new MultipleRegistration<TInterface1, TInterface2, TImplementation>(typeof(TInterface1), typeof(TInterface2), typeof(TImplementation), lifestyle, _iocContainer);
 
-        /// <summary>
+    /// <summary>
-        /// Register multiple interfaces for a <see cref="Type"/> that implements them and create a <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3}"/>
+    /// Register multiple interfaces for a <see cref="Type"/> that implements them and create a <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3}"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TInterface1">The base interface to register</typeparam>
+    /// <typeparam name="TInterface1">The base interface to register</typeparam>
-        /// <typeparam name="TInterface2">A second interface to register</typeparam>
+    /// <typeparam name="TInterface2">A second interface to register</typeparam>
-        /// <typeparam name="TInterface3">A third interface to register</typeparam>
+    /// <typeparam name="TInterface3">A third interface to register</typeparam>
-        /// <typeparam name="TImplementation">The <see cref="Type"/> that implements both interfaces</typeparam>
+    /// <typeparam name="TImplementation">The <see cref="Type"/> that implements both interfaces</typeparam>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="IRegistrationBase"/></param>
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="IRegistrationBase"/></param>
-        /// <returns>The created <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3}"/></returns>
+    /// <returns>The created <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3}"/></returns>
-        public IMultipleRegistration<TInterface1, TInterface2, TInterface3, TImplementation> Register<TInterface1, TInterface2, TInterface3, TImplementation>(Lifestyle lifestyle) where TImplementation : TInterface1, TInterface2, TInterface3 => 
+    public IMultipleRegistration<TInterface1, TInterface2, TInterface3, TImplementation> Register<TInterface1, TInterface2, TInterface3, TImplementation>(Lifestyle lifestyle) where TImplementation : TInterface1, TInterface2, TInterface3 => 
-            new MultipleRegistration<TInterface1, TInterface2, TInterface3, TImplementation>(typeof(TInterface1), typeof(TInterface2), typeof(TInterface3), typeof(TImplementation), lifestyle, _iocContainer);
+        new MultipleRegistration<TInterface1, TInterface2, TInterface3, TImplementation>(typeof(TInterface1), typeof(TInterface2), typeof(TInterface3), typeof(TImplementation), lifestyle, _iocContainer);
 
-        /// <summary>
+    /// <summary>
-        /// Register multiple interfaces for a <see cref="Type"/> that implements them and create a <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3,TInterface4}"/>
+    /// Register multiple interfaces for a <see cref="Type"/> that implements them and create a <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3,TInterface4}"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TInterface1">The base interface to register</typeparam>
+    /// <typeparam name="TInterface1">The base interface to register</typeparam>
-        /// <typeparam name="TInterface2">A second interface to register</typeparam>
+    /// <typeparam name="TInterface2">A second interface to register</typeparam>
-        /// <typeparam name="TInterface3">A third interface to register</typeparam>
+    /// <typeparam name="TInterface3">A third interface to register</typeparam>
-        /// <typeparam name="TInterface4">A fourth interface to register</typeparam>
+    /// <typeparam name="TInterface4">A fourth interface to register</typeparam>
-        /// <typeparam name="TImplementation">The <see cref="Type"/> that implements both interfaces</typeparam>
+    /// <typeparam name="TImplementation">The <see cref="Type"/> that implements both interfaces</typeparam>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="IRegistrationBase"/></param>
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="IRegistrationBase"/></param>
-        /// <returns>The created <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3,TInterface4}"/></returns>
+    /// <returns>The created <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3,TInterface4}"/></returns>
-        public IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation> Register<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation>(Lifestyle lifestyle) where TImplementation : TInterface1, TInterface2, TInterface3, TInterface4 => 
+    public IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation> Register<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation>(Lifestyle lifestyle) where TImplementation : TInterface1, TInterface2, TInterface3, TInterface4 => 
-            new MultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation>(typeof(TInterface1), typeof(TInterface2), typeof(TInterface3), typeof(TInterface4), typeof(TImplementation), lifestyle, _iocContainer);
+        new MultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TImplementation>(typeof(TInterface1), typeof(TInterface2), typeof(TInterface3), typeof(TInterface4), typeof(TImplementation), lifestyle, _iocContainer);
 
-        /// <summary>
+    /// <summary>
-        /// Register multiple interfaces for a <see cref="Type"/> that implements them and create a <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3,TInterface4,TInterface5}"/>
+    /// Register multiple interfaces for a <see cref="Type"/> that implements them and create a <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3,TInterface4,TInterface5}"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TInterface1">The base interface to register</typeparam>
+    /// <typeparam name="TInterface1">The base interface to register</typeparam>
-        /// <typeparam name="TInterface2">A second interface to register</typeparam>
+    /// <typeparam name="TInterface2">A second interface to register</typeparam>
-        /// <typeparam name="TInterface3">A third interface to register</typeparam>
+    /// <typeparam name="TInterface3">A third interface to register</typeparam>
-        /// <typeparam name="TInterface4">A fourth interface to register</typeparam>
+    /// <typeparam name="TInterface4">A fourth interface to register</typeparam>
-        /// <typeparam name="TInterface5">A fifth interface to register</typeparam>
+    /// <typeparam name="TInterface5">A fifth interface to register</typeparam>
-        /// <typeparam name="TImplementation">The <see cref="Type"/> that implements both interfaces</typeparam>
+    /// <typeparam name="TImplementation">The <see cref="Type"/> that implements both interfaces</typeparam>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="IRegistrationBase"/></param>
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="IRegistrationBase"/></param>
-        /// <returns>The created <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3,TInterface4,TInterface5}"/></returns>
+    /// <returns>The created <see cref="IMultipleRegistration{TInterface1,TInterface2,TInterface3,TInterface4,TInterface5}"/></returns>
-        public IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation> Register<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation>(Lifestyle lifestyle) where TImplementation : TInterface1, TInterface2, TInterface3, TInterface4, TInterface5 => 
+    public IMultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation> Register<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation>(Lifestyle lifestyle) where TImplementation : TInterface1, TInterface2, TInterface3, TInterface4, TInterface5 => 
-            new MultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation>(typeof(TInterface1), typeof(TInterface2), typeof(TInterface3), typeof(TInterface4), typeof(TInterface5), typeof(TImplementation), lifestyle, _iocContainer);
+        new MultipleRegistration<TInterface1, TInterface2, TInterface3, TInterface4, TInterface5, TImplementation>(typeof(TInterface1), typeof(TInterface2), typeof(TInterface3), typeof(TInterface4), typeof(TInterface5), typeof(TImplementation), lifestyle, _iocContainer);
 
-        /// <summary>
+    /// <summary>
-        /// Register a <see cref="Type"/> without an interface and create a <see cref="ISingleTypeRegistration{TInterface}"/>
+    /// Register a <see cref="Type"/> without an interface and create a <see cref="ISingleTypeRegistration{TInterface}"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="T">The <see cref="Type"/> to register</typeparam>
+    /// <typeparam name="T">The <see cref="Type"/> to register</typeparam>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="ISingleTypeRegistration{TInterface}"/></param>
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> for this <see cref="ISingleTypeRegistration{TInterface}"/></param>
-        /// <returns>A new created <see cref="ISingleTypeRegistration{TInterface}"/> with the given parameters</returns>
+    /// <returns>A new created <see cref="ISingleTypeRegistration{TInterface}"/> with the given parameters</returns>
-        public ISingleTypeRegistration<T> Register<T>(Lifestyle lifestyle) => new SingleTypeRegistration<T>(typeof(T), lifestyle, _iocContainer);
+    public ISingleTypeRegistration<T> Register<T>(Lifestyle lifestyle) => new SingleTypeRegistration<T>(typeof(T), lifestyle, _iocContainer);
 
-        /// <summary>
+    /// <summary>
-        /// Register an Interface with a Type that implements it as a multiton and create a <see cref="IMultitonRegistration{TInterface,TImplementation}"/>
+    /// Register an Interface with a Type that implements it as a multiton and create a <see cref="IMultitonRegistration{TInterface,TImplementation}"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TInterface">The Interface to register</typeparam>
+    /// <typeparam name="TInterface">The Interface to register</typeparam>
-        /// <typeparam name="TImplementation">The Type that implements the interface</typeparam>
+    /// <typeparam name="TImplementation">The Type that implements the interface</typeparam>
-        /// <typeparam name="TScope">The Type of the multiton scope</typeparam>
+    /// <typeparam name="TScope">The Type of the multiton scope</typeparam>
-        /// <returns>A new created <see cref="IMultitonRegistration{TInterface,TImplementation}"/> with the given parameters</returns>
+    /// <returns>A new created <see cref="IMultitonRegistration{TInterface,TImplementation}"/> with the given parameters</returns>
-        public IMultitonRegistration<TInterface, TImplementation> RegisterMultiton<TInterface, TImplementation, TScope>() where TImplementation : TInterface => 
+    public IMultitonRegistration<TInterface, TImplementation> RegisterMultiton<TInterface, TImplementation, TScope>() where TImplementation : TInterface => 
-            new MultitonRegistration<TInterface, TImplementation>(typeof(TInterface), typeof(TImplementation), typeof(TScope), _iocContainer);
+        new MultitonRegistration<TInterface, TImplementation>(typeof(TInterface), typeof(TImplementation), typeof(TScope), _iocContainer);
 
-        /// <summary>
+    /// <summary>
-        /// Register multiple interfaces for a <see cref="Type"/> that implements them as a multiton
+    /// Register multiple interfaces for a <see cref="Type"/> that implements them as a multiton
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TInterface1">The base interface to register</typeparam>
+    /// <typeparam name="TInterface1">The base interface to register</typeparam>
-        /// <typeparam name="TInterface2">A second interface to register</typeparam>
+    /// <typeparam name="TInterface2">A second interface to register</typeparam>
-        /// <typeparam name="TImplementation">The Type that implements the interface</typeparam>
+    /// <typeparam name="TImplementation">The Type that implements the interface</typeparam>
-        /// <typeparam name="TScope">The Type of the multiton scope</typeparam>
+    /// <typeparam name="TScope">The Type of the multiton scope</typeparam>
-        /// <returns>A new created <see cref="IMultipleMultitonRegistration{TInterface1,TInterface2,TImplementation}"/> with the given parameters</returns>
+    /// <returns>A new created <see cref="IMultipleMultitonRegistration{TInterface1,TInterface2,TImplementation}"/> with the given parameters</returns>
-        public IMultipleMultitonRegistration<TInterface1, TInterface2, TImplementation> RegisterMultiton<TInterface1, TInterface2, TImplementation, TScope>() where TImplementation : TInterface1, TInterface2 => 
+    public IMultipleMultitonRegistration<TInterface1, TInterface2, TImplementation> RegisterMultiton<TInterface1, TInterface2, TImplementation, TScope>() where TImplementation : TInterface1, TInterface2 => 
-            new MultipleMultitonRegistration<TInterface1, TInterface2, TImplementation>(typeof(TInterface1), typeof(TInterface2), typeof(TImplementation), typeof(TScope), _iocContainer);
+        new MultipleMultitonRegistration<TInterface1, TInterface2, TImplementation>(typeof(TInterface1), typeof(TInterface2), typeof(TImplementation), typeof(TScope), _iocContainer);
 
-        /// <summary>
+    /// <summary>
-        /// Register an Interface as an abstract typed factory and create a <see cref="ITypedFactoryRegistration{TFactory}"/>
+    /// Register an Interface as an abstract typed factory and create a <see cref="ITypedFactoryRegistration{TFactory}"/>
-        /// </summary>
+    /// </summary>
-        /// <typeparam name="TFactory">The abstract typed factory to register</typeparam>
+    /// <typeparam name="TFactory">The abstract typed factory to register</typeparam>
-        /// <returns>A new created <see cref="ITypedFactoryRegistration{TFactory}"/> with the given parameters</returns>
+    /// <returns>A new created <see cref="ITypedFactoryRegistration{TFactory}"/> with the given parameters</returns>
-        public ITypedFactoryRegistration<TFactory> RegisterFactory<TFactory>(ITypedFactory<TFactory> factory) => new TypedFactoryRegistration<TFactory>(factory);
+    public ITypedFactoryRegistration<TFactory> RegisterFactory<TFactory>(ITypedFactory<TFactory> factory) => new TypedFactoryRegistration<TFactory>(factory);
-    }
 }

LightweightIocContainer/Registrations/SingleTypeRegistration.cs

@@ -6,56 +6,55 @@ using System;
 using LightweightIocContainer.Interfaces;
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Registrations
+namespace LightweightIocContainer.Registrations;
+
+/// <summary>
+/// The <see cref="IRegistration"/> to register either only an interface or only a <see cref="Type"/>
+/// </summary>
+/// <typeparam name="T">The <see cref="Type"/> of the <see cref="IRegistration"/></typeparam>
+internal class SingleTypeRegistration<T> : RegistrationBase, ISingleTypeRegistration<T>
 {
     /// <summary>
     /// The <see cref="IRegistration"/> to register either only an interface or only a <see cref="Type"/>
     /// </summary>
-    /// <typeparam name="T">The <see cref="Type"/> of the <see cref="IRegistration"/></typeparam>
+    /// <param name="interfaceType">The <see cref="Type"/> of the interface or <see cref="Type"/></param>
-    internal class SingleTypeRegistration<T> : RegistrationBase, ISingleTypeRegistration<T>
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> of the <see cref="RegistrationBase"/></param>
+    /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
+    public SingleTypeRegistration(Type interfaceType, Lifestyle lifestyle, IocContainer container)
+        : base(interfaceType, lifestyle, container)
     {
-        /// <summary>
+            
-        /// The <see cref="IRegistration"/> to register either only an interface or only a <see cref="Type"/>
-        /// </summary>
-        /// <param name="interfaceType">The <see cref="Type"/> of the interface or <see cref="Type"/></param>
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> of the <see cref="RegistrationBase"/></param>
-        /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-        public SingleTypeRegistration(Type interfaceType, Lifestyle lifestyle, IocContainer container)
-            : base(interfaceType, lifestyle, container)
-        {
-            
-        }
-
-        /// <summary>
-        /// <see cref="Func{T,TResult}"/> that is invoked instead of creating an instance of this <see cref="Type"/> the default way
-        /// </summary>
-        public Func<IIocResolver, T>? FactoryMethod { get; private set; }
-
-        /// <summary>
-        /// Pass a <see cref="Func{T,TResult}"/> that will be invoked instead of creating an instance of this <see cref="Type"/> the default way
-        /// </summary>
-        /// <param name="factoryMethod">The <see cref="Func{T,TResult}"/></param>
-        /// <returns>The current instance of this <see cref="IRegistration"/></returns>
-        public ISingleTypeRegistration<T> WithFactoryMethod(Func<IIocResolver, T> factoryMethod)
-        {
-            FactoryMethod = factoryMethod;
-            return this;
-        }
-        
-        public override bool Equals(object? obj)
-        {
-            if (obj is not SingleTypeRegistration<T> singleTypeRegistration)
-                return false;
-
-            if (FactoryMethod == null && singleTypeRegistration.FactoryMethod != null)
-                return false;
-
-            if (FactoryMethod != null && singleTypeRegistration.FactoryMethod == null)
-                return false;
-            
-            return base.Equals(obj);
-        }
-
-        public override int GetHashCode() => base.GetHashCode();
     }
+
+    /// <summary>
+    /// <see cref="Func{T,TResult}"/> that is invoked instead of creating an instance of this <see cref="Type"/> the default way
+    /// </summary>
+    public Func<IIocResolver, T>? FactoryMethod { get; private set; }
+
+    /// <summary>
+    /// Pass a <see cref="Func{T,TResult}"/> that will be invoked instead of creating an instance of this <see cref="Type"/> the default way
+    /// </summary>
+    /// <param name="factoryMethod">The <see cref="Func{T,TResult}"/></param>
+    /// <returns>The current instance of this <see cref="IRegistration"/></returns>
+    public ISingleTypeRegistration<T> WithFactoryMethod(Func<IIocResolver, T> factoryMethod)
+    {
+        FactoryMethod = factoryMethod;
+        return this;
+    }
+        
+    public override bool Equals(object? obj)
+    {
+        if (obj is not SingleTypeRegistration<T> singleTypeRegistration)
+            return false;
+
+        if (FactoryMethod == null && singleTypeRegistration.FactoryMethod != null)
+            return false;
+
+        if (FactoryMethod != null && singleTypeRegistration.FactoryMethod == null)
+            return false;
+            
+        return base.Equals(obj);
+    }
+
+    public override int GetHashCode() => base.GetHashCode();
 }

LightweightIocContainer/Registrations/TypedFactoryRegistration.cs

@@ -6,34 +6,33 @@ using System;
 using LightweightIocContainer.Interfaces.Factories;
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.Registrations
+namespace LightweightIocContainer.Registrations;
+
+/// <summary>
+/// The registration that is used to register an abstract typed factory
+/// </summary>
+/// <typeparam name="TFactory">The <see cref="Type"/> of the abstract typed factory</typeparam>
+internal class TypedFactoryRegistration<TFactory> : ITypedFactoryRegistration<TFactory>
 {
     /// <summary>
     /// The registration that is used to register an abstract typed factory
     /// </summary>
-    /// <typeparam name="TFactory">The <see cref="Type"/> of the abstract typed factory</typeparam>
+    /// <param name="factory">The <see cref="ITypedFactory{TFactory}"/> for this <see cref="IRegistration"/></param>
-    internal class TypedFactoryRegistration<TFactory> : ITypedFactoryRegistration<TFactory>
+    public TypedFactoryRegistration(ITypedFactory<TFactory> factory) => Factory = factory;
-    {
-        /// <summary>
-        /// The registration that is used to register an abstract typed factory
-        /// </summary>
-        /// <param name="factory">The <see cref="ITypedFactory{TFactory}"/> for this <see cref="IRegistration"/></param>
-        public TypedFactoryRegistration(ITypedFactory<TFactory> factory) => Factory = factory;
 
-        /// <summary>
+    /// <summary>
-        /// The <see cref="Type"/> of the factory that is registered with this <see cref="IRegistration"/>
+    /// The <see cref="Type"/> of the factory that is registered with this <see cref="IRegistration"/>
-        /// </summary>
+    /// </summary>
-        public Type InterfaceType => typeof(TFactory);
+    public Type InterfaceType => typeof(TFactory);
         
-        /// <summary>
+    /// <summary>
-        /// The class that contains the implemented abstract factory of this <see cref="TypedFactoryRegistration{TFactory}"/>
+    /// The class that contains the implemented abstract factory of this <see cref="TypedFactoryRegistration{TFactory}"/>
-        /// </summary>
+    /// </summary>
-        public ITypedFactory<TFactory> Factory { get; }
+    public ITypedFactory<TFactory> Factory { get; }
 
-        public override bool Equals(object? obj) => obj is TypedFactoryRegistration<TFactory> factoryRegistration && 
+    public override bool Equals(object? obj) => obj is TypedFactoryRegistration<TFactory> factoryRegistration && 
-                                                    Factory.CreateMethods.Count == factoryRegistration.Factory.CreateMethods.Count &&
+                                                Factory.CreateMethods.Count == factoryRegistration.Factory.CreateMethods.Count &&
-                                                    InterfaceType == factoryRegistration.InterfaceType;
+                                                InterfaceType == factoryRegistration.InterfaceType;
 
-        public override int GetHashCode() => HashCode.Combine(InterfaceType);
+    public override int GetHashCode() => HashCode.Combine(InterfaceType);
-    }
 }

LightweightIocContainer/Registrations/TypedRegistration.cs

@@ -8,74 +8,73 @@ using LightweightIocContainer.Interfaces.Installers;
 using LightweightIocContainer.Interfaces.Registrations;
 using LightweightIocContainer.Interfaces.Registrations.Fluent;
 
-namespace LightweightIocContainer.Registrations
+namespace LightweightIocContainer.Registrations;
+
+/// <summary>
+/// A <see cref="IRegistrationBase"/> that implements a <see cref="Type"/>
+/// </summary>
+internal class TypedRegistration<TInterface, TImplementation> : RegistrationBase, ITypedRegistration<TInterface, TImplementation> where TImplementation : TInterface
 {
     /// <summary>
     /// A <see cref="IRegistrationBase"/> that implements a <see cref="Type"/>
     /// </summary>
-    internal class TypedRegistration<TInterface, TImplementation> : RegistrationBase, ITypedRegistration<TInterface, TImplementation> where TImplementation : TInterface
+    /// <param name="interfaceType">The <see cref="Type"/> of the interface</param>
-    {
+    /// <param name="implementationType">The <see cref="Type"/> of the implementation type</param>
-        /// <summary>
+    /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="IRegistrationBase"/></param>
-        /// A <see cref="IRegistrationBase"/> that implements a <see cref="Type"/>
+    /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-        /// </summary>
+    public TypedRegistration(Type interfaceType, Type implementationType, Lifestyle lifestyle, IocContainer container)
-        /// <param name="interfaceType">The <see cref="Type"/> of the interface</param>
+        : base(interfaceType, lifestyle, container) =>
-        /// <param name="implementationType">The <see cref="Type"/> of the implementation type</param>
+        ImplementationType = implementationType;
-        /// <param name="lifestyle">The <see cref="Lifestyle"/> of this <see cref="IRegistrationBase"/></param>
-        /// <param name="container">The current instance of the <see cref="IIocContainer"/></param>
-        public TypedRegistration(Type interfaceType, Type implementationType, Lifestyle lifestyle, IocContainer container)
-            : base(interfaceType, lifestyle, container) =>
-            ImplementationType = implementationType;
-
-        /// <summary>
-        /// The <see cref="Type"/> that implements the <see cref="IRegistration.InterfaceType"/> that is registered with this <see cref="IRegistrationBase"/>
-        /// </summary>
-        public Type ImplementationType { get; }
 
-        /// <summary>
+    /// <summary>
-        /// This <see cref="Action"/> is invoked when an instance of this type is created.
+    /// The <see cref="Type"/> that implements the <see cref="IRegistration.InterfaceType"/> that is registered with this <see cref="IRegistrationBase"/>
-        /// <para>Can be set in the <see cref="IIocInstaller"/> by calling <see cref="IOnCreate{TInterface,TImplementation}.OnCreate"/></para>
+    /// </summary>
-        /// </summary>
+    public Type ImplementationType { get; }
-        private Action<object?>? OnCreateAction { get; set; }
 
-        /// <summary>
+    /// <summary>
-        /// This <see cref="Action"/> is invoked when an instance of this type is created.
+    /// This <see cref="Action"/> is invoked when an instance of this type is created.
-        /// <para>Can be set in the <see cref="IIocInstaller"/> by calling <see cref="IOnCreate{TInterface,TImplementation}.OnCreate"/></para>
+    /// <para>Can be set in the <see cref="IIocInstaller"/> by calling <see cref="IOnCreate{TInterface,TImplementation}.OnCreate"/></para>
-        /// </summary>
+    /// </summary>
-        Action<object?>? IOnCreate.OnCreateAction => OnCreateAction;
+    private Action<object?>? OnCreateAction { get; set; }
 
-        /// <summary>
+    /// <summary>
-        /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
+    /// This <see cref="Action"/> is invoked when an instance of this type is created.
-        /// </summary>
+    /// <para>Can be set in the <see cref="IIocInstaller"/> by calling <see cref="IOnCreate{TInterface,TImplementation}.OnCreate"/></para>
-        /// <param name="action">The <see cref="Action{T}"/></param>
+    /// </summary>
-        /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
+    Action<object?>? IOnCreate.OnCreateAction => OnCreateAction;
-        public virtual ITypedRegistration<TInterface, TImplementation> OnCreate(Action<TImplementation?> action)
-        {
-            OnCreateAction = a => action((TImplementation?) a);
-            return this;
-        }
 
-        /// <summary>
+    /// <summary>
-        /// Validate the <see cref="DisposeStrategy"/> for the <see cref="ImplementationType"/> and <see cref="Lifestyle"/>
+    /// Pass an <see cref="Action{T}"/> that will be invoked when an instance of this type is created
-        /// </summary>
+    /// </summary>
-        protected override void ValidateDisposeStrategy() => ValidateDisposeStrategy(ImplementationType);
+    /// <param name="action">The <see cref="Action{T}"/></param>
+    /// <returns>The current instance of this <see cref="ITypedRegistration{TInterface,TImplementation}"/></returns>
+    public virtual ITypedRegistration<TInterface, TImplementation> OnCreate(Action<TImplementation?> action)
+    {
+        OnCreateAction = a => action((TImplementation?) a);
+        return this;
+    }
 
-        public override bool Equals(object? obj)
+    /// <summary>
-        {
+    /// Validate the <see cref="DisposeStrategy"/> for the <see cref="ImplementationType"/> and <see cref="Lifestyle"/>
-            if (obj is not TypedRegistration<TInterface, TImplementation> typedRegistration)
+    /// </summary>
-                return false;
+    protected override void ValidateDisposeStrategy() => ValidateDisposeStrategy(ImplementationType);
 
-            if (!base.Equals(obj))
+    public override bool Equals(object? obj)
-                return false;
+    {
+        if (obj is not TypedRegistration<TInterface, TImplementation> typedRegistration)
+            return false;
 
-            if (OnCreateAction == null && typedRegistration.OnCreateAction != null)
+        if (!base.Equals(obj))
-                return false;
+            return false;
 
-            if (OnCreateAction != null && typedRegistration.OnCreateAction == null)
+        if (OnCreateAction == null && typedRegistration.OnCreateAction != null)
-                return false;
+            return false;
 
-            return ImplementationType == typedRegistration.ImplementationType;
+        if (OnCreateAction != null && typedRegistration.OnCreateAction == null)
-        }
+            return false;
             
-        public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), ImplementationType);
+        return ImplementationType == typedRegistration.ImplementationType;
     }
+
+    public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), ImplementationType);
 }

LightweightIocContainer/ResolvePlaceholders/InternalResolvePlaceholder.cs

@@ -2,13 +2,12 @@
 // Created: 2019-11-22
 // Copyright(c) 2019 SimonG. All Rights Reserved.
 
-namespace LightweightIocContainer.ResolvePlaceholders
+namespace LightweightIocContainer.ResolvePlaceholders;
+
+/// <summary>
+/// An internal placeholder that is used during the resolving process
+/// </summary>
+internal class InternalResolvePlaceholder
 {
-    /// <summary>
-    /// An internal placeholder that is used during the resolving process
-    /// </summary>
-    internal class InternalResolvePlaceholder
-    {
         
-    }
 }

LightweightIocContainer/ResolvePlaceholders/InternalToBeResolvedPlaceholder.cs

@@ -6,33 +6,32 @@ using System;
 using System.Collections.Generic;
 using LightweightIocContainer.Interfaces.Registrations;
 
-namespace LightweightIocContainer.ResolvePlaceholders
+namespace LightweightIocContainer.ResolvePlaceholders;
+
+/// <summary>
+/// An internal placeholder that is used to hold types that need to be resolved during the resolving process
+/// </summary>
+internal class InternalToBeResolvedPlaceholder : IInternalToBeResolvedPlaceholder
 {
-    /// <summary>
+    public InternalToBeResolvedPlaceholder(Type resolvedType, IRegistration resolvedRegistration, List<object?>? parameters)
-    /// An internal placeholder that is used to hold types that need to be resolved during the resolving process
-    /// </summary>
-    internal class InternalToBeResolvedPlaceholder : IInternalToBeResolvedPlaceholder
     {
-        public InternalToBeResolvedPlaceholder(Type resolvedType, IRegistration resolvedRegistration, List<object?>? parameters)
+        ResolvedType = resolvedType;
-        {
+        ResolvedRegistration = resolvedRegistration;
-            ResolvedType = resolvedType;
+        Parameters = parameters;
-            ResolvedRegistration = resolvedRegistration;
+    }
-            Parameters = parameters;
-        }
 
-        /// <summary>
+    /// <summary>
-        /// The <see cref="Type"/> to be resolved
+    /// The <see cref="Type"/> to be resolved
-        /// </summary>
+    /// </summary>
-        public Type ResolvedType { get; }
+    public Type ResolvedType { get; }
         
-        /// <summary>
+    /// <summary>
-        /// The <see cref="IRegistration"/> to be resolved
+    /// The <see cref="IRegistration"/> to be resolved
-        /// </summary>
+    /// </summary>
-        public IRegistration ResolvedRegistration { get; }
+    public IRegistration ResolvedRegistration { get; }
         
-        /// <summary>
+    /// <summary>
-        /// The parameters needed to resolve the <see cref="ResolvedRegistration"/>
+    /// The parameters needed to resolve the <see cref="ResolvedRegistration"/>
-        /// </summary>
+    /// </summary>
-        public List<object?>? Parameters { get; }
+    public List<object?>? Parameters { get; }
-    }
 }

LightweightIocContainer/TypeExtension.cs

@@ -4,15 +4,14 @@
 
 using System;
 
-namespace LightweightIocContainer
+namespace LightweightIocContainer;
+
+internal static class TypeExtension
 {
-    internal static class TypeExtension
+    /// <summary>
-    {
+    /// Returns the default value for a given <see cref="Type"/>
-        /// <summary>
+    /// </summary>
-        /// Returns the default value for a given <see cref="Type"/>
+    /// <param name="type">The given <see cref="Type"/></param>
-        /// </summary>
+    /// <returns>The default value for the given <see cref="Type"/></returns>
-        /// <param name="type">The given <see cref="Type"/></param>
+    public static object? GetDefault(this Type type) => type.IsValueType ? Activator.CreateInstance(type) : null;
-        /// <returns>The default value for the given <see cref="Type"/></returns>
-        public static object? GetDefault(this Type type) => type.IsValueType ? Activator.CreateInstance(type) : null;
-    }
 }

LightweightIocContainer/Validation/IocValidator.cs

@@ -9,98 +9,97 @@ using LightweightIocContainer.Interfaces.Registrations;
 using LightweightIocContainer.Interfaces.Registrations.Fluent;
 using Moq;
 
-namespace LightweightIocContainer.Validation
+namespace LightweightIocContainer.Validation;
+
+/// <summary>
+/// Validator for your <see cref="IocContainer"/> to check if everything can be resolved with your current setup
+/// </summary>
+public class IocValidator
 {
+    private readonly IocContainer _iocContainer;
+    private readonly List<(Type type, object? parameter)> _parameters;
+
     /// <summary>
     /// Validator for your <see cref="IocContainer"/> to check if everything can be resolved with your current setup
     /// </summary>
-    public class IocValidator
+    /// <param name="iocContainer">The <see cref="IocContainer"/></param>
+    public IocValidator(IocContainer iocContainer)
     {
-        private readonly IocContainer _iocContainer;
+        _iocContainer = iocContainer;
-        private readonly List<(Type type, object? parameter)> _parameters;
+        _parameters = new List<(Type, object?)>();
+    }
 
-        /// <summary>
+    /// <summary>
-        /// Validator for your <see cref="IocContainer"/> to check if everything can be resolved with your current setup
+    /// Add parameters that can't be default for your type to be created successfully
-        /// </summary>
+    /// </summary>
-        /// <param name="iocContainer">The <see cref="IocContainer"/></param>
+    /// <param name="parameter">The new value of the parameter</param>
-        public IocValidator(IocContainer iocContainer)
+    /// <typeparam name="TInterface">The <see cref="Type"/> of your registered interface</typeparam>
-        {
+    /// <typeparam name="TParameter">The <see cref="Type"/> of your <paramref name="parameter"></paramref></typeparam>
-            _iocContainer = iocContainer;
+    public void AddParameter<TInterface, TParameter>(TParameter parameter) => _parameters.Add((typeof(TInterface), parameter));
-            _parameters = new List<(Type, object?)>();
-        }
         
-        /// <summary>
+    /// <summary>
-        /// Add parameters that can't be default for your type to be created successfully
+    /// Validates your given <see cref="IocContainer"/> and checks if everything can be resolved with the current setup
-        /// </summary>
+    /// <exception cref="AggregateException">Collection of all exceptions that are thrown during validation</exception>
-        /// <param name="parameter">The new value of the parameter</param>
+    /// </summary>
-        /// <typeparam name="TInterface">The <see cref="Type"/> of your registered interface</typeparam>
+    public void Validate()
-        /// <typeparam name="TParameter">The <see cref="Type"/> of your <paramref name="parameter"></paramref></typeparam>
+    {
-        public void AddParameter<TInterface, TParameter>(TParameter parameter) => _parameters.Add((typeof(TInterface), parameter));
+        List<Exception> validationExceptions = new();
             
-        /// <summary>
+        foreach (IRegistration registration in _iocContainer.Registrations)
-        /// Validates your given <see cref="IocContainer"/> and checks if everything can be resolved with the current setup
-        /// <exception cref="AggregateException">Collection of all exceptions that are thrown during validation</exception>
-        /// </summary>
-        public void Validate()
         {
-            List<Exception> validationExceptions = new();
+            var definedParameters = _parameters.Where(p => p.type == registration.InterfaceType);
                 
-            foreach (IRegistration registration in _iocContainer.Registrations)
+            if (registration is IWithFactoryInternal { Factory: { } } withFactoryRegistration)
             {
-                var definedParameters = _parameters.Where(p => p.type == registration.InterfaceType);
+                (from createMethod in withFactoryRegistration.Factory.CreateMethods
-                
-                if (registration is IWithFactoryInternal { Factory: { } } withFactoryRegistration)
-                {
-                    (from createMethod in withFactoryRegistration.Factory.CreateMethods
                         select createMethod.GetParameters().Select(p => p.ParameterType)
                         into parameterTypes 
                         select (from parameterType in parameterTypes
                             let definedParameter = definedParameters
                                 .FirstOrDefault(p => parameterType.IsInstanceOfType(p.parameter))
                             select definedParameter == default ? GetMockOrDefault(parameterType) : definedParameter.parameter).ToArray())
-                        .ToList()
+                    .ToList()
-                        .ForEach(p => TryResolve(registration.InterfaceType, p, validationExceptions, true));
+                    .ForEach(p => TryResolve(registration.InterfaceType, p, validationExceptions, true));
-                }
-                else
-                {
-                    object?[] arguments = definedParameters.Select(p => p.parameter).ToArray();
-                    TryResolve(registration.InterfaceType, arguments, validationExceptions);
-                }
-            }
-
-            if (validationExceptions.Any())
-                throw new AggregateException("Validation failed.", validationExceptions);
-        }
-
-        private void TryResolve(Type type, object?[]? arguments, List<Exception> validationExceptions, bool isFactoryResolve = false)
-        {
-            try
-            {
-                _iocContainer.TryResolveNonGeneric(type, arguments, null, isFactoryResolve);
             }
-            catch (Exception exception)
+            else
             {
-                validationExceptions.Add(exception);
+                object?[] arguments = definedParameters.Select(p => p.parameter).ToArray();
+                TryResolve(registration.InterfaceType, arguments, validationExceptions);
             }
         }
 
-        private T GetMock<T>() where T : class => new Mock<T>().Object;
+        if (validationExceptions.Any())
-        private object? GetMockOrDefault(Type type)
+            throw new AggregateException("Validation failed.", validationExceptions);
+    }
+
+    private void TryResolve(Type type, object?[]? arguments, List<Exception> validationExceptions, bool isFactoryResolve = false)
+    {
+        try
+        {
+            _iocContainer.TryResolveNonGeneric(type, arguments, null, isFactoryResolve);
+        }
+        catch (Exception exception)
         {
-            if (type.IsValueType)
+            validationExceptions.Add(exception);
-                return Activator.CreateInstance(type);
+        }
+    }
+
+    private T GetMock<T>() where T : class => new Mock<T>().Object;
+    private object? GetMockOrDefault(Type type)
+    {
+        if (type.IsValueType)
+            return Activator.CreateInstance(type);
 
-            if (type == typeof(string))
+        if (type == typeof(string))
-                return string.Empty;
+            return string.Empty;
             
-            try
+        try
-            {
+        {
-                return GenericMethodCaller.CallPrivate(this, nameof(GetMock), type);
+            return GenericMethodCaller.CallPrivate(this, nameof(GetMock), type);
-            }
+        }
-            catch (Exception)
+        catch (Exception)
-            {
+        {
-                return null; 
+            return null; 
-            }
         }
     }
 }

Test.LightweightIocContainer/ActionExtensionTest.cs

@@ -6,41 +6,40 @@ using System;
 using LightweightIocContainer;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class ActionExtensionTest
 {
-    [TestFixture]
+    private interface IBar
-    public class ActionExtensionTest
     {
-        private interface IBar
+        void Throw();
-        {
+    }
-            void Throw();
-        }
 
-        private interface IFoo : IBar
+    private interface IFoo : IBar
-        {
+    {
 
-        }
+    }
 
-        private class Foo : IFoo
+    private class Foo : IFoo
-        {
+    {
-            public void Throw() => throw new Exception();
+        public void Throw() => throw new Exception();
-        }
+    }
         
 
-        [Test]
+    [Test]
-        public void TestConvert()
+    public void TestConvert()
-        {
+    {
-            Action<IBar> barAction = bar => bar.Throw();
+        Action<IBar> barAction = bar => bar.Throw();
-            Action<IFoo> action = barAction.Convert<IFoo, IBar>();
+        Action<IFoo> action = barAction.Convert<IFoo, IBar>();
 
-            Assert.Throws<Exception>(() => action(new Foo()));
+        Assert.Throws<Exception>(() => action(new Foo()));
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestConvertActionNull()
+    public void TestConvertActionNull()
-        {
+    {
-            Action<IBar> barAction = null;
+        Action<IBar> barAction = null;
-            Assert.Null(barAction.Convert<IFoo, IBar>());
+        Assert.Null(barAction.Convert<IFoo, IBar>());
-        }
     }
 }

Test.LightweightIocContainer/AssemblyInstallerTest.cs

@@ -14,65 +14,64 @@ using LightweightIocContainer.Interfaces.Registrations;
 using Moq;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class AssemblyInstallerTest
 {
-    [TestFixture]
+    [UsedImplicitly]
-    public class AssemblyInstallerTest
+    public class TestInstaller : IIocInstaller
     {
-        [UsedImplicitly]
+        public void Install(IRegistrationCollector registration) => registration.Add<Mock<IRegistration>>();
-        public class TestInstaller : IIocInstaller
+    }
-        {
-            public void Install(IRegistrationCollector registration) => registration.Add<Mock<IRegistration>>();
-        }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public class AssemblyWrapper : Assembly
+    public class AssemblyWrapper : Assembly
-        {
+    {
 
-        }
+    }
 
         
-        [Test]
+    [Test]
-        public void TestInstall()
+    public void TestInstall()
+    {
+        List<Type> types = new()
         {
-            List<Type> types = new()
+            typeof(object),
-            {
+            typeof(TestInstaller)
-                typeof(object),
+        };
-                typeof(TestInstaller)
-            };
 
-            Mock<AssemblyWrapper> assemblyMock = new();
+        Mock<AssemblyWrapper> assemblyMock = new();
-            assemblyMock.Setup(a => a.GetTypes()).Returns(types.ToArray);
+        assemblyMock.Setup(a => a.GetTypes()).Returns(types.ToArray);
 
-            Mock<IRegistrationCollector> registrationCollectorMock = new();
+        Mock<IRegistrationCollector> registrationCollectorMock = new();
 
-            AssemblyInstaller assemblyInstaller = new(assemblyMock.Object);
+        AssemblyInstaller assemblyInstaller = new(assemblyMock.Object);
-            assemblyInstaller.Install(registrationCollectorMock.Object);
+        assemblyInstaller.Install(registrationCollectorMock.Object);
 
-            registrationCollectorMock.Verify(r => r.Add<It.IsSubtype<Mock<IRegistration>>>(It.IsAny<Lifestyle>()), Times.Once);
+        registrationCollectorMock.Verify(r => r.Add<It.IsSubtype<Mock<IRegistration>>>(It.IsAny<Lifestyle>()), Times.Once);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestFromAssemblyThis()
+    public void TestFromAssemblyThis()
-        {
+    {
-            IIocContainer iocContainer = new IocContainer();
+        IIocContainer iocContainer = new IocContainer();
-            iocContainer.Install(FromAssembly.This());
+        iocContainer.Install(FromAssembly.This());
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestFromAssemblyInstance()
+    public void TestFromAssemblyInstance()
+    {
+        List<Type> types = new()
         {
-            List<Type> types = new()
+            typeof(object),
-            {
+            typeof(TestInstaller)
-                typeof(object),
+        };
-                typeof(TestInstaller)
-            };
 
-            Mock<AssemblyWrapper> assemblyMock = new();
+        Mock<AssemblyWrapper> assemblyMock = new();
-            assemblyMock.Setup(a => a.GetTypes()).Returns(types.ToArray);
+        assemblyMock.Setup(a => a.GetTypes()).Returns(types.ToArray);
 
-            IIocContainer iocContainer = new IocContainer();
+        IIocContainer iocContainer = new IocContainer();
-            iocContainer.Install(FromAssembly.Instance(assemblyMock.Object));
+        iocContainer.Install(FromAssembly.Instance(assemblyMock.Object));
-        }
     }
 }

Test.LightweightIocContainer/EnumerableExtensionTest.cs

@@ -9,94 +9,93 @@ using LightweightIocContainer;
 using Moq;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class EnumerableExtensionTest
 {
-    [TestFixture]
+    private class ListObject
-    public class EnumerableExtensionTest
     {
-        private class ListObject
+        public int Index { get; set; }
-        {
+    }
-            public int Index { get; set; }
-        }
 
-        private class Given : ListObject
+    private class Given : ListObject
-        {
+    {
 
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface ITest
+    public interface ITest
-        {
+    {
-            void DoSomething();
+        void DoSomething();
-        }
+    }
 
 
-        [Test]
+    [Test]
-        [SuppressMessage("ReSharper", "CollectionNeverUpdated.Local")]
+    [SuppressMessage("ReSharper", "CollectionNeverUpdated.Local")]
-        public void TestFirstOrGivenNoPredicateEmpty()
+    public void TestFirstOrGivenNoPredicateEmpty()
-        {
+    {
-            List<ListObject> list = new();
+        List<ListObject> list = new();
-            Assert.IsInstanceOf<Given>(list.FirstOrGiven<ListObject, Given>());
+        Assert.IsInstanceOf<Given>(list.FirstOrGiven<ListObject, Given>());
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestFirstOrGivenNoPredicate()
+    public void TestFirstOrGivenNoPredicate()
-        {
+    {
-            List<ListObject> list = new()
+        List<ListObject> list = new()
-            {
-                new ListObject {Index = 0},
-                new ListObject {Index = 1},
-                new ListObject {Index = 2},
-                new ListObject {Index = 3}
-            };
-
-            ListObject listObject = list.FirstOrGiven<ListObject, Given>();
-            
-            Assert.IsNotInstanceOf<Given>(listObject);
-            Assert.AreEqual(0, listObject.Index);
-        }
-
-        [Test]
-        [SuppressMessage("ReSharper", "CollectionNeverUpdated.Local")]
-        public void TestFirstOrGivenPredicateEmpty()
         {
-            List<ListObject> list = new();
+            new ListObject {Index = 0},
-            Assert.IsInstanceOf<Given>(list.FirstOrGiven<ListObject, Given>(o => o.Index == 2));
+            new ListObject {Index = 1},
-        }
+            new ListObject {Index = 2},
+            new ListObject {Index = 3}
+        };
 
-        [Test]
+        ListObject listObject = list.FirstOrGiven<ListObject, Given>();
-        public void TestFirstOrGivenPredicate()
+            
-        {
+        Assert.IsNotInstanceOf<Given>(listObject);
-            List<ListObject> list = new()
+        Assert.AreEqual(0, listObject.Index);
-            {
+    }
-                new ListObject {Index = 0},
+
-                new ListObject {Index = 1},
+    [Test]
-                new ListObject {Index = 2},
+    [SuppressMessage("ReSharper", "CollectionNeverUpdated.Local")]
-                new ListObject {Index = 3}
+    public void TestFirstOrGivenPredicateEmpty()
-            };
+    {
-
+        List<ListObject> list = new();
-            ListObject listObject = list.FirstOrGiven<ListObject, Given>(o => o.Index == 2);
+        Assert.IsInstanceOf<Given>(list.FirstOrGiven<ListObject, Given>(o => o.Index == 2));
-
+    }
-            Assert.IsNotInstanceOf<Given>(listObject);
+
-            Assert.AreEqual(2, listObject.Index);
+    [Test]
-        }
+    public void TestFirstOrGivenPredicate()
-
+    {
-        [Test]
+        List<ListObject> list = new()
-        public void TestForEach()
         {
-            Mock<ITest> test1 = new();
+            new ListObject {Index = 0},
-            Mock<ITest> test2 = new();
+            new ListObject {Index = 1},
-            Mock<ITest> test3 = new();
+            new ListObject {Index = 2},
-            Mock<ITest> test4 = new();
+            new ListObject {Index = 3}
+        };
+
+        ListObject listObject = list.FirstOrGiven<ListObject, Given>(o => o.Index == 2);
+
+        Assert.IsNotInstanceOf<Given>(listObject);
+        Assert.AreEqual(2, listObject.Index);
+    }
+
+    [Test]
+    public void TestForEach()
+    {
+        Mock<ITest> test1 = new();
+        Mock<ITest> test2 = new();
+        Mock<ITest> test3 = new();
+        Mock<ITest> test4 = new();
 
-            IEnumerable<ITest> enumerable = new[] { test1.Object, test2.Object, test3.Object, test4.Object };
+        IEnumerable<ITest> enumerable = new[] { test1.Object, test2.Object, test3.Object, test4.Object };
             
-            enumerable.ForEach(t => t.DoSomething());
+        enumerable.ForEach(t => t.DoSomething());
             
-            test1.Verify(t => t.DoSomething(), Times.Once);
+        test1.Verify(t => t.DoSomething(), Times.Once);
-            test2.Verify(t => t.DoSomething(), Times.Once);
+        test2.Verify(t => t.DoSomething(), Times.Once);
-            test3.Verify(t => t.DoSomething(), Times.Once);
+        test3.Verify(t => t.DoSomething(), Times.Once);
-            test4.Verify(t => t.DoSomething(), Times.Once);
+        test4.Verify(t => t.DoSomething(), Times.Once);
-        }
     }
 }

Test.LightweightIocContainer/FluentFactoryRegistrationTest.cs

@@ -7,267 +7,266 @@ using LightweightIocContainer;
 using LightweightIocContainer.Exceptions;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class FluentFactoryRegistrationTest
 {
-    [TestFixture]
+    public interface ITest
-    public class FluentFactoryRegistrationTest
     {
-        public interface ITest
-        {
-            
-        }
             
-        private class Test : ITest
+    }
-        {
-            
-        }
 
-        private class TestByte : ITest
+    private class Test : ITest
-        {
+    {
-            [UsedImplicitly]
-            private readonly byte _id;
             
-            public TestByte(byte id) => _id = id;
+    }
-        }
         
+    private class TestByte : ITest
+    {
         [UsedImplicitly]
-        private class TestConstructor : ITest
+        private readonly byte _id;
-        {
-            public TestConstructor(string name, Test test)
-            {
-
-            }
-
-            public TestConstructor(Test test, string name = null)
-            {
 
-            }
+        public TestByte(byte id) => _id = id;
-        }
+    }
         
-        private interface ITestFactoryNoCreate
+    [UsedImplicitly]
+    private class TestConstructor : ITest
+    {
+        public TestConstructor(string name, Test test)
         {
 
         }
 
-        private interface ITestFactoryNonGenericClear
+        public TestConstructor(Test test, string name = null)
         {
-            ITest Create();
 
-            void ClearMultitonInstance();
         }
+    }
         
-        [UsedImplicitly]
+    private interface ITestFactoryNoCreate
-        public interface ITestFactory
+    {
-        {
-            ITest Create();
-            ITest Create(string name);
-            ITest CreateTest(string name = null);
-            ITest Create(byte id);
-        }
             
-        private class TestFactory : ITestFactory
+    }
-        {
-            public ITest Create() => new Test();
-            public ITest Create(string name) => throw new System.NotImplementedException();
-            public ITest CreateTest(string name = null) => throw new System.NotImplementedException();
-            public ITest Create(byte id) => throw new System.NotImplementedException();
-        }
 
-        [UsedImplicitly]
+    private interface ITestFactoryNonGenericClear
-        public interface IMultitonTestFactory
+    {
-        {
+        ITest Create();
-            ITest Create(MultitonScope scope);
-            void ClearMultitonInstance<T>();
-        }
 
-        [UsedImplicitly]
+        void ClearMultitonInstance();
-        public interface IInvalidMultitonTestFactory
+    }
-        {
-            ITest Create(MultitonScope scope);
-            ITest Create(int number);
-        }
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface ITestFactoryWrongReturn
+    public interface ITestFactory
-        {
+    {
-            public MultitonScope Create();
+        ITest Create();
-        }
+        ITest Create(string name);
+        ITest CreateTest(string name = null);
+        ITest Create(byte id);
+    }
         
-        public class MultitonScope
+    private class TestFactory : ITestFactory
-        {
+    {
+        public ITest Create() => new Test();
+        public ITest Create(string name) => throw new System.NotImplementedException();
+        public ITest CreateTest(string name = null) => throw new System.NotImplementedException();
+        public ITest Create(byte id) => throw new System.NotImplementedException();
+    }
         
-        }
+    [UsedImplicitly]
+    public interface IMultitonTestFactory
+    {
+        ITest Create(MultitonScope scope);
+        void ClearMultitonInstance<T>();
+    }
         
-        private IocContainer _iocContainer;
+    [UsedImplicitly]
+    public interface IInvalidMultitonTestFactory
+    {
+        ITest Create(MultitonScope scope);
+        ITest Create(int number);
+    }
         
-        [SetUp]
+    [UsedImplicitly]
-        public void SetUp() => _iocContainer = new IocContainer();
+    public interface ITestFactoryWrongReturn
+    {
+        public MultitonScope Create();
+    }
         
-        [TearDown]
+    public class MultitonScope
-        public void TearDown() => _iocContainer.Dispose();
+    {
 
-        [Test]
+    }
-        public void TestFluentFactoryRegistration()
-        {
-            _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory>());
         
-            ITestFactory factory = _iocContainer.Resolve<ITestFactory>();
+    private IocContainer _iocContainer;
-            ITest test = factory.Create();
-            ITest test2 = factory.CreateTest();
 
-            Assert.IsInstanceOf<ITestFactory>(factory);
+    [SetUp]
-            Assert.IsInstanceOf<ITest>(test);
+    public void SetUp() => _iocContainer = new IocContainer();
-            Assert.IsInstanceOf<ITest>(test2);
-        }
 
-        [Test]
+    [TearDown]
-        public void TestFluentFactoryRegistrationResolveWithoutFactoryFails()
+    public void TearDown() => _iocContainer.Dispose();
-        {
-            _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory>());
-            Assert.Throws<DirectResolveWithRegisteredFactoryNotAllowed>(()=>_iocContainer.Resolve<ITest>());
-        }
         
-        [Test]
+    [Test]
-        public void TestFluentFactoryRegistration_CustomFactory()
+    public void TestFluentFactoryRegistration()
-        {
+    {
-            _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory, TestFactory>());
+        _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory>());
 
-            ITestFactory factory = _iocContainer.Resolve<ITestFactory>();
+        ITestFactory factory = _iocContainer.Resolve<ITestFactory>();
-            ITest test = factory.Create();
+        ITest test = factory.Create();
+        ITest test2 = factory.CreateTest();
             
-            Assert.IsInstanceOf<ITestFactory>(factory);
+        Assert.IsInstanceOf<ITestFactory>(factory);
-            Assert.IsInstanceOf<ITest>(test);
+        Assert.IsInstanceOf<ITest>(test);
-        }
+        Assert.IsInstanceOf<ITest>(test2);
+    }
         
-        [Test]
+    [Test]
-        public void TestFluentFactoryRegistration_WithoutFactoryFails()
+    public void TestFluentFactoryRegistrationResolveWithoutFactoryFails()
-        {
+    {
-            _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory, TestFactory>());
+        _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory>());
-            Assert.Throws<DirectResolveWithRegisteredFactoryNotAllowed>(()=>_iocContainer.Resolve<ITest>());
+        Assert.Throws<DirectResolveWithRegisteredFactoryNotAllowed>(()=>_iocContainer.Resolve<ITest>());
-        }
+    }
         
+    [Test]
+    public void TestFluentFactoryRegistration_CustomFactory()
+    {
+        _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory, TestFactory>());
 
-        [Test]
+        ITestFactory factory = _iocContainer.Resolve<ITestFactory>();
-        public void TestRegisterFactoryWithoutCreate() => Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactoryNoCreate>()));
+        ITest test = factory.Create();
             
-        [Test]
+        Assert.IsInstanceOf<ITestFactory>(factory);
-        public void TestRegisterFactoryClearMultitonsNonGeneric() => Assert.Throws<IllegalAbstractMethodCreationException>(() => _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactoryNonGenericClear>()));
+        Assert.IsInstanceOf<ITest>(test);
+    }
         
-        [Test]
+    [Test]
-        public void TestResolveFromFactory()
+    public void TestFluentFactoryRegistration_WithoutFactoryFails()
-        {
+    {
-            _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory>());
+        _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory, TestFactory>());
+        Assert.Throws<DirectResolveWithRegisteredFactoryNotAllowed>(()=>_iocContainer.Resolve<ITest>());
+    }
 
-            ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
-            ITest createdTest = testFactory.Create();
         
-            Assert.IsInstanceOf<Test>(createdTest);
+    [Test]
-        }
+    public void TestRegisterFactoryWithoutCreate() => Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactoryNoCreate>()));
         
-        [Test]
+    [Test]
-        public void TestResolveFromFactoryWithParams()
+    public void TestRegisterFactoryClearMultitonsNonGeneric() => Assert.Throws<IllegalAbstractMethodCreationException>(() => _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactoryNonGenericClear>()));
-        {
-            _iocContainer.Register(r => r.Add<ITest, TestConstructor>().WithFactory<ITestFactory>());
-            _iocContainer.Register(r => r.Add<Test, Test>()); //this registration is abnormal and should only be used in unit tests
         
-            ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
+    [Test]
-            ITest createdTest = testFactory.Create("Test");
+    public void TestResolveFromFactory()
+    {
+        _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactory>());
         
-            Assert.IsInstanceOf<TestConstructor>(createdTest);
+        ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
-        }
+        ITest createdTest = testFactory.Create();
         
-        [Test]
+        Assert.IsInstanceOf<Test>(createdTest);
-        public void TestResolveFromFactoryWithDefaultParamCreate()
+    }
-        {
-            _iocContainer.Register(r => r.Add<ITest, TestConstructor>().WithFactory<ITestFactory>());
-            _iocContainer.Register(r => r.Add<Test, Test>()); //this registration is abnormal and should only be used in unit tests
         
-            ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
+    [Test]
-            ITest createdTest = testFactory.CreateTest();
+    public void TestResolveFromFactoryWithParams()
+    {
+        _iocContainer.Register(r => r.Add<ITest, TestConstructor>().WithFactory<ITestFactory>());
+        _iocContainer.Register(r => r.Add<Test, Test>()); //this registration is abnormal and should only be used in unit tests
         
-            Assert.IsInstanceOf<TestConstructor>(createdTest);
+        ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
-        }
+        ITest createdTest = testFactory.Create("Test");
         
-        [Test]
+        Assert.IsInstanceOf<TestConstructor>(createdTest);
-        public void TestResolveFromFactoryWithDefaultParamCtor()
+    }
-        {
-            _iocContainer.Register(r => r.Add<ITest, TestConstructor>().WithFactory<ITestFactory>());
-            _iocContainer.Register(r => r.Add<Test, Test>()); //this registration is abnormal and should only be used in unit tests
         
-            ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
+    [Test]
-            ITest createdTest = testFactory.Create();
+    public void TestResolveFromFactoryWithDefaultParamCreate()
+    {
+        _iocContainer.Register(r => r.Add<ITest, TestConstructor>().WithFactory<ITestFactory>());
+        _iocContainer.Register(r => r.Add<Test, Test>()); //this registration is abnormal and should only be used in unit tests
         
-            Assert.IsInstanceOf<TestConstructor>(createdTest);
+        ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
-        }
+        ITest createdTest = testFactory.CreateTest();
         
-        [Test]
+        Assert.IsInstanceOf<TestConstructor>(createdTest);
-        public void TestResolveFromFactoryWithByte()
+    }
-        {
-            _iocContainer.Register(r => r.Add<ITest, TestByte>().WithFactory<ITestFactory>());
         
-            ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
+    [Test]
-            ITest createdTest = testFactory.Create(1);
+    public void TestResolveFromFactoryWithDefaultParamCtor()
+    {
+        _iocContainer.Register(r => r.Add<ITest, TestConstructor>().WithFactory<ITestFactory>());
+        _iocContainer.Register(r => r.Add<Test, Test>()); //this registration is abnormal and should only be used in unit tests
         
-            Assert.IsInstanceOf<TestByte>(createdTest);
+        ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
-        }
+        ITest createdTest = testFactory.Create();
         
-        [Test]
+        Assert.IsInstanceOf<TestConstructor>(createdTest);
-        public void TestResolveMultitonFromFactory()
+    }
-        {
-            _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>().WithFactory<IMultitonTestFactory>());
         
-            MultitonScope scope1 = new();
+    [Test]
-            MultitonScope scope2 = new();
+    public void TestResolveFromFactoryWithByte()
+    {
+        _iocContainer.Register(r => r.Add<ITest, TestByte>().WithFactory<ITestFactory>());
         
-            IMultitonTestFactory testFactory = _iocContainer.Resolve<IMultitonTestFactory>();
+        ITestFactory testFactory = _iocContainer.Resolve<ITestFactory>();
+        ITest createdTest = testFactory.Create(1);
         
-            ITest resolvedTest1 = testFactory.Create(scope1);
+        Assert.IsInstanceOf<TestByte>(createdTest);
-            ITest resolvedTest2 = testFactory.Create(scope1);
+    }
-            ITest resolvedTest3 = testFactory.Create(scope2);
         
-            Assert.AreSame(resolvedTest1, resolvedTest2);
+    [Test]
-            Assert.AreNotSame(resolvedTest1, resolvedTest3);
+    public void TestResolveMultitonFromFactory()
-            Assert.AreNotSame(resolvedTest2, resolvedTest3);
+    {
-        }
+        _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>().WithFactory<IMultitonTestFactory>());
         
-        [Test]
+        MultitonScope scope1 = new();
-        public void TestResolveMultitonFromFactoryClearInstances()
+        MultitonScope scope2 = new();
-        {
+        
-            _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>().WithFactory<IMultitonTestFactory>());
+        IMultitonTestFactory testFactory = _iocContainer.Resolve<IMultitonTestFactory>();
         
-            MultitonScope scope1 = new();
+        ITest resolvedTest1 = testFactory.Create(scope1);
-            MultitonScope scope2 = new();
+        ITest resolvedTest2 = testFactory.Create(scope1);
+        ITest resolvedTest3 = testFactory.Create(scope2);
         
-            IMultitonTestFactory testFactory = _iocContainer.Resolve<IMultitonTestFactory>();
+        Assert.AreSame(resolvedTest1, resolvedTest2);
+        Assert.AreNotSame(resolvedTest1, resolvedTest3);
+        Assert.AreNotSame(resolvedTest2, resolvedTest3);
+    }
         
-            ITest resolvedTest1 = testFactory.Create(scope1);
+    [Test]
-            ITest resolvedTest2 = testFactory.Create(scope1);
+    public void TestResolveMultitonFromFactoryClearInstances()
-            ITest resolvedTest3 = testFactory.Create(scope2);
+    {
+        _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>().WithFactory<IMultitonTestFactory>());
         
-            Assert.AreSame(resolvedTest1, resolvedTest2);
+        MultitonScope scope1 = new();
-            Assert.AreNotSame(resolvedTest1, resolvedTest3);
+        MultitonScope scope2 = new();
-            Assert.AreNotSame(resolvedTest2, resolvedTest3);
         
-            testFactory.ClearMultitonInstance<ITest>();
+        IMultitonTestFactory testFactory = _iocContainer.Resolve<IMultitonTestFactory>();
         
-            ITest resolvedTest4 = testFactory.Create(scope1);
+        ITest resolvedTest1 = testFactory.Create(scope1);
-            ITest resolvedTest5 = testFactory.Create(scope2);
+        ITest resolvedTest2 = testFactory.Create(scope1);
+        ITest resolvedTest3 = testFactory.Create(scope2);
         
-            Assert.AreNotSame(resolvedTest1, resolvedTest4);
+        Assert.AreSame(resolvedTest1, resolvedTest2);
-            Assert.AreNotSame(resolvedTest2, resolvedTest4);
+        Assert.AreNotSame(resolvedTest1, resolvedTest3);
-            Assert.AreNotSame(resolvedTest3, resolvedTest5);
+        Assert.AreNotSame(resolvedTest2, resolvedTest3);
-        }
         
-        [Test]
+        testFactory.ClearMultitonInstance<ITest>();
-        public void InvalidMultitonFactoryRegistrationFactoryWithoutParameter() => 
-            Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>().WithFactory<ITestFactory>()));
         
-        [Test]
+        ITest resolvedTest4 = testFactory.Create(scope1);
-        public void InvalidMultitonFactoryRegistrationFactoryWithoutScopeAsFirstParameter() => 
+        ITest resolvedTest5 = testFactory.Create(scope2);
-            Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>().WithFactory<IInvalidMultitonTestFactory>()));
         
-        [Test]
+        Assert.AreNotSame(resolvedTest1, resolvedTest4);
-        public void TestInvalidCreateMethodReturnType() => 
+        Assert.AreNotSame(resolvedTest2, resolvedTest4);
-            Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactoryWrongReturn>()));
+        Assert.AreNotSame(resolvedTest3, resolvedTest5);
     }
+
+    [Test]
+    public void InvalidMultitonFactoryRegistrationFactoryWithoutParameter() => 
+        Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>().WithFactory<ITestFactory>()));
+        
+    [Test]
+    public void InvalidMultitonFactoryRegistrationFactoryWithoutScopeAsFirstParameter() => 
+        Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>().WithFactory<IInvalidMultitonTestFactory>()));
+
+    [Test]
+    public void TestInvalidCreateMethodReturnType() => 
+        Assert.Throws<InvalidFactoryRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, Test>().WithFactory<ITestFactoryWrongReturn>()));
 }

Test.LightweightIocContainer/IocContainerInterfaceSegregationTest.cs

@@ -7,158 +7,157 @@ using JetBrains.Annotations;
 using LightweightIocContainer;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class IocContainerInterfaceSegregationTest
 {
-    [TestFixture]
+    private interface IBar
-    public class IocContainerInterfaceSegregationTest
+    {
+            
+    }
+
+    private interface IFoo
+    {
+        void ThrowFoo();
+    }
+    private interface IAnotherBar
+    {
+            
+    }
+
+    private interface IAnotherFoo
+    {
+            
+    }
+
+    private interface IAnotherOne
+    {
+            
+    }
+
+    [UsedImplicitly]
+    private class Foo : IFoo, IBar, IAnotherFoo, IAnotherBar, IAnotherOne
+    {
+        public void ThrowFoo() => throw new Exception("Foo");
+    }
+
+
+    private IocContainer _container;
+
+    [SetUp]
+    public void SetUp() => _container = new IocContainer();
+
+    [TearDown]
+    public void TearDown() => _container.Dispose();
+
+    [Test]
+    public void TestRegistrationOnCreate2()
+    {
+        _container.Register(r => r.Add<IBar, IFoo, Foo>().OnCreate(foo => foo.ThrowFoo()));
+
+        Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
+        Assert.AreEqual("Foo", fooException?.Message);
+            
+        Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
+        Assert.AreEqual("Foo", barException?.Message);
+    }
+
+    [Test]
+    public void TestRegistrationOnCreate3()
     {
-        private interface IBar
+        _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, Foo>().OnCreate(foo => foo.ThrowFoo()));
-        {
 
-        }
+        Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
+        Assert.AreEqual("Foo", fooException?.Message);
 
-        private interface IFoo
+        Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
-        {
+        Assert.AreEqual("Foo", barException?.Message);
-            void ThrowFoo();
-        }
-        private interface IAnotherBar
-        {
 
-        }
+        Exception anotherFooException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherFoo>());
+        Assert.AreEqual("Foo", anotherFooException?.Message);
+    }
 
-        private interface IAnotherFoo
+    [Test]
-        {
+    public void TestRegistrationOnCreate4()
+    {
+        _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, IAnotherBar, Foo>().OnCreate(foo => foo.ThrowFoo()));
 
-        }
+        Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
+        Assert.AreEqual("Foo", fooException?.Message);
 
-        private interface IAnotherOne
+        Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
-        {
+        Assert.AreEqual("Foo", barException?.Message);
 
-        }
+        Exception anotherFooException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherFoo>());
+        Assert.AreEqual("Foo", anotherFooException?.Message);
+
+        Exception anotherBarException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherBar>());
+        Assert.AreEqual("Foo", anotherBarException?.Message);
+    }
 
-        [UsedImplicitly]
+    [Test]
-        private class Foo : IFoo, IBar, IAnotherFoo, IAnotherBar, IAnotherOne
+    public void TestRegistrationOnCreate5()
-        {
+    {
-            public void ThrowFoo() => throw new Exception("Foo");
+        _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, IAnotherBar, IAnotherOne, Foo>().OnCreate(foo => foo.ThrowFoo()));
-        }
 
+        Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
+        Assert.AreEqual("Foo", fooException?.Message);
 
-        private IocContainer _container;
+        Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
+        Assert.AreEqual("Foo", barException?.Message);
 
-        [SetUp]
+        Exception anotherFooException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherFoo>());
-        public void SetUp() => _container = new IocContainer();
+        Assert.AreEqual("Foo", anotherFooException?.Message);
 
-        [TearDown]
+        Exception anotherBarException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherBar>());
-        public void TearDown() => _container.Dispose();
+        Assert.AreEqual("Foo", anotherBarException?.Message);
 
-        [Test]
+        Exception anotherOneException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherOne>());
-        public void TestRegistrationOnCreate2()
+        Assert.AreEqual("Foo", anotherOneException?.Message);
-        {
+    }
-            _container.Register(r => r.Add<IBar, IFoo, Foo>().OnCreate(foo => foo.ThrowFoo()));
 
-            Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
+    [Test]
-            Assert.AreEqual("Foo", fooException?.Message);
+    public void TestResolveTransient()
+    {
+        _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, IAnotherBar, IAnotherOne, Foo>());
+        IFoo foo = _container.Resolve<IFoo>();
+        IBar bar = _container.Resolve<IBar>();
+        IAnotherFoo anotherFoo = _container.Resolve<IAnotherFoo>();
+        IAnotherBar anotherBar = _container.Resolve<IAnotherBar>();
+        IAnotherOne anotherOne = _container.Resolve<IAnotherOne>();
+
+        Assert.IsInstanceOf<Foo>(foo);
+        Assert.IsInstanceOf<Foo>(bar);
+        Assert.IsInstanceOf<Foo>(anotherFoo);
+        Assert.IsInstanceOf<Foo>(anotherBar);
+        Assert.IsInstanceOf<Foo>(anotherOne);
+    }
 
-            Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
+    [Test]
-            Assert.AreEqual("Foo", barException?.Message);
+    public void TestResolveSingleton()
-        }
+    {
-
+        _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, IAnotherBar, IAnotherOne, Foo>(Lifestyle.Singleton));
-        [Test]
+        IFoo foo = _container.Resolve<IFoo>();
-        public void TestRegistrationOnCreate3()
+        IBar bar = _container.Resolve<IBar>();
-        {
+        IAnotherFoo anotherFoo = _container.Resolve<IAnotherFoo>();
-            _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, Foo>().OnCreate(foo => foo.ThrowFoo()));
+        IAnotherBar anotherBar = _container.Resolve<IAnotherBar>();
-
+        IAnotherOne anotherOne = _container.Resolve<IAnotherOne>();
-            Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
+
-            Assert.AreEqual("Foo", fooException?.Message);
+        Assert.IsInstanceOf<Foo>(foo);
-
+        Assert.IsInstanceOf<Foo>(bar);
-            Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
+        Assert.IsInstanceOf<Foo>(anotherFoo);
-            Assert.AreEqual("Foo", barException?.Message);
+        Assert.IsInstanceOf<Foo>(anotherBar);
-
+        Assert.IsInstanceOf<Foo>(anotherOne);
-            Exception anotherFooException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherFoo>());
+            
-            Assert.AreEqual("Foo", anotherFooException?.Message);
+        Assert.AreEqual(foo, bar);
-        }
+        Assert.AreEqual(foo, anotherFoo);
-
+        Assert.AreEqual(foo, anotherBar);
-        [Test]
+        Assert.AreEqual(foo, anotherOne);
-        public void TestRegistrationOnCreate4()
+
-        {
+        Assert.AreSame(foo, bar);
-            _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, IAnotherBar, Foo>().OnCreate(foo => foo.ThrowFoo()));
+        Assert.AreSame(foo, anotherFoo);
-
+        Assert.AreSame(foo, anotherBar);
-            Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
+        Assert.AreSame(foo, anotherOne);
-            Assert.AreEqual("Foo", fooException?.Message);
-
-            Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
-            Assert.AreEqual("Foo", barException?.Message);
-
-            Exception anotherFooException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherFoo>());
-            Assert.AreEqual("Foo", anotherFooException?.Message);
-
-            Exception anotherBarException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherBar>());
-            Assert.AreEqual("Foo", anotherBarException?.Message);
-        }
-
-        [Test]
-        public void TestRegistrationOnCreate5()
-        {
-            _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, IAnotherBar, IAnotherOne, Foo>().OnCreate(foo => foo.ThrowFoo()));
-
-            Exception fooException = Assert.Throws<Exception>(() => _container.Resolve<IFoo>());
-            Assert.AreEqual("Foo", fooException?.Message);
-
-            Exception barException = Assert.Throws<Exception>(() => _container.Resolve<IBar>());
-            Assert.AreEqual("Foo", barException?.Message);
-
-            Exception anotherFooException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherFoo>());
-            Assert.AreEqual("Foo", anotherFooException?.Message);
-
-            Exception anotherBarException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherBar>());
-            Assert.AreEqual("Foo", anotherBarException?.Message);
-
-            Exception anotherOneException = Assert.Throws<Exception>(() => _container.Resolve<IAnotherOne>());
-            Assert.AreEqual("Foo", anotherOneException?.Message);
-        }
-
-        [Test]
-        public void TestResolveTransient()
-        {
-            _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, IAnotherBar, IAnotherOne, Foo>());
-            IFoo foo = _container.Resolve<IFoo>();
-            IBar bar = _container.Resolve<IBar>();
-            IAnotherFoo anotherFoo = _container.Resolve<IAnotherFoo>();
-            IAnotherBar anotherBar = _container.Resolve<IAnotherBar>();
-            IAnotherOne anotherOne = _container.Resolve<IAnotherOne>();
-
-            Assert.IsInstanceOf<Foo>(foo);
-            Assert.IsInstanceOf<Foo>(bar);
-            Assert.IsInstanceOf<Foo>(anotherFoo);
-            Assert.IsInstanceOf<Foo>(anotherBar);
-            Assert.IsInstanceOf<Foo>(anotherOne);
-        }
-
-        [Test]
-        public void TestResolveSingleton()
-        {
-            _container.Register(r => r.Add<IBar, IFoo, IAnotherFoo, IAnotherBar, IAnotherOne, Foo>(Lifestyle.Singleton));
-            IFoo foo = _container.Resolve<IFoo>();
-            IBar bar = _container.Resolve<IBar>();
-            IAnotherFoo anotherFoo = _container.Resolve<IAnotherFoo>();
-            IAnotherBar anotherBar = _container.Resolve<IAnotherBar>();
-            IAnotherOne anotherOne = _container.Resolve<IAnotherOne>();
-
-            Assert.IsInstanceOf<Foo>(foo);
-            Assert.IsInstanceOf<Foo>(bar);
-            Assert.IsInstanceOf<Foo>(anotherFoo);
-            Assert.IsInstanceOf<Foo>(anotherBar);
-            Assert.IsInstanceOf<Foo>(anotherOne);
-            
-            Assert.AreEqual(foo, bar);
-            Assert.AreEqual(foo, anotherFoo);
-            Assert.AreEqual(foo, anotherBar);
-            Assert.AreEqual(foo, anotherOne);
-
-            Assert.AreSame(foo, bar);
-            Assert.AreSame(foo, anotherFoo);
-            Assert.AreSame(foo, anotherBar);
-            Assert.AreSame(foo, anotherOne);
-        }
     }
 }

Test.LightweightIocContainer/IocContainerParameterRegistrationTest.cs

@@ -6,154 +6,153 @@ using JetBrains.Annotations;
 using LightweightIocContainer;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+// ReSharper disable MemberHidesStaticFromOuterClass
+public class IocContainerParameterRegistrationTest
 {
-    [TestFixture]
+    [UsedImplicitly]
-    // ReSharper disable MemberHidesStaticFromOuterClass
+    public interface IA
-    public class IocContainerParameterRegistrationTest
     {
-        [UsedImplicitly]
+        IB B { get; }
-        public interface IA
+        IC C { get; }
-        {
+    }
-            IB B { get; }
-            IC C { get; }
-        }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface IB
+    public interface IB
-        {
+    {
 
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface IC
+    public interface IC
-        {
+    {
 
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface ID
+    public interface ID
-        {
+    {
-            IA A { get; }
+        IA A { get; }
-            IA A2 { get; }
+        IA A2 { get; }
-            IB B { get; }
+        IB B { get; }
-            IC C { get; }
+        IC C { get; }
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class A : IA
+    private class A : IA
+    {
+        public A(IB b, IC c)
         {
-            public A(IB b, IC c)
+            B = b;
-            {
+            C = c;
-                B = b;
-                C = c;
-            }
-
-            public IB B { get; }
-            public IC C { get; }
         }
 
-        [UsedImplicitly]
+        public IB B { get; }
-        private class B : IB
+        public IC C { get; }
+    }
+
+    [UsedImplicitly]
+    private class B : IB
+    {
+        public B(IC c)
         {
-            public B(IC c)
-            {
                 
-            }
         }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class C : IC
+    private class C : IC
-        {
+    {
 
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class D : ID
+    private class D : ID
+    {
+        public D(IA a, IA a2, IB b, IC c)
         {
-            public D(IA a, IA a2, IB b, IC c)
+            A = a;
-            {
+            A2 = a2;
-                A = a;
+            B = b;
-                A2 = a2;
+            C = c;
-                B = b;
-                C = c;
-            }
-
-            public IA A { get; }
-            public IA A2 { get; }
-            public IB B { get; }
-            public IC C { get; }
         }
 
+        public IA A { get; }
+        public IA A2 { get; }
+        public IB B { get; }
+        public IC C { get; }
+    }
 
-        private IocContainer _iocContainer;
         
-        [SetUp]
+    private IocContainer _iocContainer;
-        public void SetUp() => _iocContainer = new IocContainer();
 
-        [TearDown]
+    [SetUp]
-        public void TearDown() => _iocContainer.Dispose();
+    public void SetUp() => _iocContainer = new IocContainer();
 
+    [TearDown]
+    public void TearDown() => _iocContainer.Dispose();
 
-        [Test]
-        public void TestResolveOnlyRegistrationParameters()
-        {
-            IC c = new C();
-            IB b = new B(c);
 
-            _iocContainer.Register(r => r.Add<IA, A>().WithParameters(b, c));
+    [Test]
-            IA a = _iocContainer.Resolve<IA>();
+    public void TestResolveOnlyRegistrationParameters()
+    {
+        IC c = new C();
+        IB b = new B(c);
             
-            Assert.AreEqual(b, a.B);
+        _iocContainer.Register(r => r.Add<IA, A>().WithParameters(b, c));
-            Assert.AreEqual(c, a.C);
+        IA a = _iocContainer.Resolve<IA>();
-        }
             
-        [Test]
+        Assert.AreEqual(b, a.B);
-        public void TestResolveRegistrationAndResolveParameters()
+        Assert.AreEqual(c, a.C);
-        {
+    }
-            IC c = new C();
-            IB b = new B(c);
 
-            _iocContainer.Register(r => r.Add<IA, A>().WithParameters(b));
+    [Test]
-            IA a = _iocContainer.Resolve<IA>(c);
+    public void TestResolveRegistrationAndResolveParameters()
+    {
+        IC c = new C();
+        IB b = new B(c);
 
-            Assert.AreEqual(b, a.B);
+        _iocContainer.Register(r => r.Add<IA, A>().WithParameters(b));
-            Assert.AreEqual(c, a.C);
+        IA a = _iocContainer.Resolve<IA>(c);
-        }
 
-        [Test]
+        Assert.AreEqual(b, a.B);
-        public void TestResolveRegistrationAndResolveParametersMixedOrder()
+        Assert.AreEqual(c, a.C);
-        {
+    }
-            IC c = new C();
-            IB b = new B(c);
-            IA a = new A(b, c);
-            IA a2 = new A(b, c);
-
-            _iocContainer.Register(r => r.Add<ID, D>().WithParameters((0, a), (2, b), (3, c)));
-            ID d = _iocContainer.Resolve<ID>(a2);
-
-            Assert.AreEqual(a, d.A);
-            Assert.AreEqual(a2, d.A2);
-            Assert.AreEqual(b, d.B);
-            Assert.AreEqual(c, d.C);
-        }
 
-        [Test]
+    [Test]
-        public void TestResolveRegistrationParametersAndResolvedParameters()
+    public void TestResolveRegistrationAndResolveParametersMixedOrder()
-        {
+    {
-            IC c = new C();
+        IC c = new C();
-            IB b = new B(c);
+        IB b = new B(c);
-            IA a = new A(b, c);
+        IA a = new A(b, c);
-            IA a2 = new A(b, c);
+        IA a2 = new A(b, c);
+
+        _iocContainer.Register(r => r.Add<ID, D>().WithParameters((0, a), (2, b), (3, c)));
+        ID d = _iocContainer.Resolve<ID>(a2);
+
+        Assert.AreEqual(a, d.A);
+        Assert.AreEqual(a2, d.A2);
+        Assert.AreEqual(b, d.B);
+        Assert.AreEqual(c, d.C);
+    }
 
-            _iocContainer.Register(r => r.Add<ID, D>().WithParameters(a2));
+    [Test]
-            _iocContainer.Register(r => r.Add<IB, B>());
+    public void TestResolveRegistrationParametersAndResolvedParameters()
-            _iocContainer.Register(r => r.Add<IC, C>());
+    {
+        IC c = new C();
+        IB b = new B(c);
+        IA a = new A(b, c);
+        IA a2 = new A(b, c);
 
-            ID d = _iocContainer.Resolve<ID>(a);
+        _iocContainer.Register(r => r.Add<ID, D>().WithParameters(a2));
+        _iocContainer.Register(r => r.Add<IB, B>());
+        _iocContainer.Register(r => r.Add<IC, C>());
 
-            Assert.AreEqual(a, d.A2);
+        ID d = _iocContainer.Resolve<ID>(a);
-            Assert.AreEqual(a2, d.A);
+
-        }
+        Assert.AreEqual(a, d.A2);
+        Assert.AreEqual(a2, d.A);
     }
 }

Test.LightweightIocContainer/IocContainerRecursionTest.cs

@@ -9,158 +9,157 @@ using LightweightIocContainer.Exceptions;
 using Moq;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class IocContainerRecursionTest
 {
-    [TestFixture]
+    [UsedImplicitly]
-    public class IocContainerRecursionTest
+    public interface IFoo
     {
-        [UsedImplicitly]
-        public interface IFoo
-        {
 
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface IBar
+    public interface IBar
-        {
+    {
 
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class Foo : IFoo
+    private class Foo : IFoo
+    {
+        public Foo(IBar bar)
         {
-            public Foo(IBar bar)
-            {
-            }
         }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class Bar : IBar
+    private class Bar : IBar
+    {
+        public Bar(IFoo foo)
         {
-            public Bar(IFoo foo)
-            {
-            }
         }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface IA
+    public interface IA
-        {
+    {
             
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface IB
+    public interface IB
-        {
+    {
             
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface IC
+    public interface IC
-        {
+    {
             
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class A : IA
+    private class A : IA
+    {
+        public A(IB b, IC c)
         {
-            public A(IB b, IC c)
-            {
                 
-            }
         }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class B : IB
+    private class B : IB
+    {
+        public B(IC c)
         {
-            public B(IC c)
-            {
                 
-            }
         }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class C : IC
+    private class C : IC
-        {
+    {
 
-        }
+    }
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class ATwoCtor : IA
+    private class ATwoCtor : IA
-        {
+    {
-            public ATwoCtor(IB b) => Console.WriteLine("A with args");
+        public ATwoCtor(IB b) => Console.WriteLine("A with args");
-            public ATwoCtor() => Console.WriteLine("A without args");
+        public ATwoCtor() => Console.WriteLine("A without args");
-        }
+    }
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class BTwoCtor : IB
+    private class BTwoCtor : IB
-        {
+    {
-            public BTwoCtor(IA a) => Console.WriteLine("B with args");
+        public BTwoCtor(IA a) => Console.WriteLine("B with args");
-            public BTwoCtor() => Console.WriteLine("B without args");
+        public BTwoCtor() => Console.WriteLine("B without args");
-        }
+    }
 
 
-        private IocContainer _iocContainer;
+    private IocContainer _iocContainer;
 
-        [SetUp]
+    [SetUp]
-        public void SetUp() => _iocContainer = new IocContainer();
+    public void SetUp() => _iocContainer = new IocContainer();
 
-        [TearDown]
+    [TearDown]
-        public void TearDown() => _iocContainer.Dispose();
+    public void TearDown() => _iocContainer.Dispose();
 
-        [Test]
+    [Test]
-        public void TestCircularDependencies()
+    public void TestCircularDependencies()
-        {
+    {
-            _iocContainer.Register(r => r.Add<IFoo, Foo>());
+        _iocContainer.Register(r => r.Add<IFoo, Foo>());
-            _iocContainer.Register(r => r.Add<IBar, Bar>());
+        _iocContainer.Register(r => r.Add<IBar, Bar>());
 
-            NoMatchingConstructorFoundException noMatchingConstructorFoundException = Assert.Throws<NoMatchingConstructorFoundException>(() => _iocContainer.Resolve<IFoo>());
+        NoMatchingConstructorFoundException noMatchingConstructorFoundException = Assert.Throws<NoMatchingConstructorFoundException>(() => _iocContainer.Resolve<IFoo>());
-            ConstructorNotMatchingException fooConstructorNotMatchingException = (ConstructorNotMatchingException) noMatchingConstructorFoundException?.InnerExceptions[0];
+        ConstructorNotMatchingException fooConstructorNotMatchingException = (ConstructorNotMatchingException) noMatchingConstructorFoundException?.InnerExceptions[0];
-            NoMatchingConstructorFoundException noMatchingBarConstructorFoundException = (NoMatchingConstructorFoundException) fooConstructorNotMatchingException?.InnerExceptions[0]; 
+        NoMatchingConstructorFoundException noMatchingBarConstructorFoundException = (NoMatchingConstructorFoundException) fooConstructorNotMatchingException?.InnerExceptions[0]; 
-            ConstructorNotMatchingException barConstructorNotMatchingException = (ConstructorNotMatchingException) noMatchingBarConstructorFoundException?.InnerExceptions[0];
+        ConstructorNotMatchingException barConstructorNotMatchingException = (ConstructorNotMatchingException) noMatchingBarConstructorFoundException?.InnerExceptions[0];
             
-            CircularDependencyException exception = (CircularDependencyException) barConstructorNotMatchingException?.InnerExceptions[0];
+        CircularDependencyException exception = (CircularDependencyException) barConstructorNotMatchingException?.InnerExceptions[0];
             
-            Assert.AreEqual(typeof(IFoo), exception?.ResolvingType);
+        Assert.AreEqual(typeof(IFoo), exception?.ResolvingType);
-            Assert.AreEqual(2, exception.ResolveStack.Count);
+        Assert.AreEqual(2, exception.ResolveStack.Count);
 
-            string message = $"Circular dependency has been detected when trying to resolve `{typeof(IFoo)}`.\n" +
+        string message = $"Circular dependency has been detected when trying to resolve `{typeof(IFoo)}`.\n" +
-                             "Resolve stack that resulted in the circular dependency:\n" +
+                         "Resolve stack that resulted in the circular dependency:\n" +
-                             $"\t`{typeof(IFoo)}` resolved as dependency of\n" +
+                         $"\t`{typeof(IFoo)}` resolved as dependency of\n" +
-                             $"\t`{typeof(IBar)}` resolved as dependency of\n" +
+                         $"\t`{typeof(IBar)}` resolved as dependency of\n" +
-                             $"\t`{typeof(IFoo)}` which is the root type being resolved.";
+                         $"\t`{typeof(IFoo)}` which is the root type being resolved.";
 
-            Assert.AreEqual(message, exception.Message);
+        Assert.AreEqual(message, exception.Message);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestNonCircularDependencies()
+    public void TestNonCircularDependencies()
-        {
+    {
-            _iocContainer.Register(r => r.Add<IA, A>());
+        _iocContainer.Register(r => r.Add<IA, A>());
-            _iocContainer.Register(r => r.Add<IB, B>());
+        _iocContainer.Register(r => r.Add<IB, B>());
-            _iocContainer.Register(r => r.Add<IC, C>());
+        _iocContainer.Register(r => r.Add<IC, C>());
 
-            IA a = _iocContainer.Resolve<IA>();
+        IA a = _iocContainer.Resolve<IA>();
-            Assert.IsNotNull(a);
+        Assert.IsNotNull(a);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestRecursionWithParam()
+    public void TestRecursionWithParam()
-        {
+    {
-            _iocContainer.Register(r => r.Add<IFoo, Foo>());
+        _iocContainer.Register(r => r.Add<IFoo, Foo>());
-            _iocContainer.Register(r => r.Add<IBar, Bar>());
+        _iocContainer.Register(r => r.Add<IBar, Bar>());
 
-            Assert.DoesNotThrow(() => _iocContainer.Resolve<IFoo>(new Mock<IBar>().Object));
+        Assert.DoesNotThrow(() => _iocContainer.Resolve<IFoo>(new Mock<IBar>().Object));
-            Assert.DoesNotThrow(() => _iocContainer.Resolve<IBar>(new Mock<IFoo>().Object));
+        Assert.DoesNotThrow(() => _iocContainer.Resolve<IBar>(new Mock<IFoo>().Object));
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestNonCircularCrossDependencies()
+    public void TestNonCircularCrossDependencies()
-        {
+    {
-            _iocContainer.Register(r => r.Add<IA, ATwoCtor>());
+        _iocContainer.Register(r => r.Add<IA, ATwoCtor>());
-            _iocContainer.Register(r => r.Add<IB, BTwoCtor>());
+        _iocContainer.Register(r => r.Add<IB, BTwoCtor>());
 
-            Assert.DoesNotThrow(() => _iocContainer.Resolve<IA>());
+        Assert.DoesNotThrow(() => _iocContainer.Resolve<IA>());
-            Assert.DoesNotThrow(() => _iocContainer.Resolve<IB>());
+        Assert.DoesNotThrow(() => _iocContainer.Resolve<IB>());
-        }
     }
 }

Test.LightweightIocContainer/IocContainerTest.cs

@@ -7,356 +7,355 @@ using LightweightIocContainer.Interfaces.Registrations;
 using Moq;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class IocContainerTest
 {
-    [TestFixture]
+    private interface ITest
-    public class IocContainerTest
     {
-        private interface ITest
-        {
 
-        }
+    }
 
-        private interface IFoo
+    private interface IFoo
-        {
+    {
 
-        }
+    }
 
-        private class Test : ITest
+    private class Test : ITest
-        {
+    {
 
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class TestConstructor : ITest
+    private class TestConstructor : ITest
+    {
+        public TestConstructor(string name, Test test)
         {
-            public TestConstructor(string name, Test test)
-            {
-
-            }
-
-            public TestConstructor(Test test, string name = null)
-            {
-
-            }
-
-            public TestConstructor(IFoo foo, string name)
-            {
 
-            }
         }
 
-        [UsedImplicitly]
+        public TestConstructor(Test test, string name = null)
-        private class TestPrivateConstructor : ITest
         {
-            private TestPrivateConstructor()
-            {
 
-            }
         }
 
-        [UsedImplicitly]
+        public TestConstructor(IFoo foo, string name)
-        private class TestMultipleConstructors : ITest
         {
-            public TestMultipleConstructors(string name, bool success)
-            {
 
-            }
-
-            public TestMultipleConstructors(string name)
-            {
-
-            }
         }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class TestWithFoo : ITest
+    private class TestPrivateConstructor : ITest
+    {
+        private TestPrivateConstructor()
         {
-            public TestWithFoo(IFoo testFoo) => TestFoo = testFoo;
+
-            public IFoo TestFoo { get; }
         }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class Foo : IFoo
+    private class TestMultipleConstructors : ITest
+    {
+        public TestMultipleConstructors(string name, bool success)
         {
 
         }
 
-        [UsedImplicitly]
+        public TestMultipleConstructors(string name)
-        private class FooConstructor : IFoo
         {
-            public FooConstructor(string test)
-            {
 
-            }
         }
+    }
 
-        private class MultitonScope
+    [UsedImplicitly]
+    private class TestWithFoo : ITest
+    {
+        public TestWithFoo(IFoo testFoo) => TestFoo = testFoo;
+        public IFoo TestFoo { get; }
+    }
+
+    [UsedImplicitly]
+    private class Foo : IFoo
+    {
+
+    }
+
+    [UsedImplicitly]
+    private class FooConstructor : IFoo
+    {
+        public FooConstructor(string test)
         {
                 
         }
+    }
 
+    private class MultitonScope
+    {
 
-        private IocContainer _iocContainer;
+    }
 
-        [SetUp]
-        public void SetUp() => _iocContainer = new IocContainer();
 
-        [TearDown]
+    private IocContainer _iocContainer;
-        public void TearDown() => _iocContainer.Dispose();
 
+    [SetUp]
+    public void SetUp() => _iocContainer = new IocContainer();
 
-        [Test]
+    [TearDown]
-        public void TestInstall()
+    public void TearDown() => _iocContainer.Dispose();
-        {
-            Mock<IIocInstaller> installerMock = new();
-            IIocContainer returnedContainer = _iocContainer.Install(installerMock.Object);
 
-            installerMock.Verify(m => m.Install(It.IsAny<IRegistrationCollector>()), Times.Once);
 
-            Assert.AreEqual(_iocContainer, returnedContainer);
+    [Test]
-        }
+    public void TestInstall()
+    {
+        Mock<IIocInstaller> installerMock = new();
+        IIocContainer returnedContainer = _iocContainer.Install(installerMock.Object);
 
-        [Test]
+        installerMock.Verify(m => m.Install(It.IsAny<IRegistrationCollector>()), Times.Once);
-        public void TestInstallMultiple()
-        {
-            Mock<IIocInstaller> installer1Mock = new();
-            Mock<IIocInstaller> installer2Mock = new();
-            Mock<IIocInstaller> installer3Mock = new();
 
-            IIocContainer returnedContainer = _iocContainer.Install(installer1Mock.Object, installer2Mock.Object, installer3Mock.Object);
+        Assert.AreEqual(_iocContainer, returnedContainer);
+    }
 
-            installer1Mock.Verify(m => m.Install(It.IsAny<IRegistrationCollector>()), Times.Once);
+    [Test]
-            installer2Mock.Verify(m => m.Install(It.IsAny<IRegistrationCollector>()), Times.Once);
+    public void TestInstallMultiple()
-            installer3Mock.Verify(m => m.Install(It.IsAny<IRegistrationCollector>()), Times.Once);
+    {
+        Mock<IIocInstaller> installer1Mock = new();
+        Mock<IIocInstaller> installer2Mock = new();
+        Mock<IIocInstaller> installer3Mock = new();
 
-            Assert.AreEqual(_iocContainer, returnedContainer);
+        IIocContainer returnedContainer = _iocContainer.Install(installer1Mock.Object, installer2Mock.Object, installer3Mock.Object);
-        }
 
-        [Test]
+        installer1Mock.Verify(m => m.Install(It.IsAny<IRegistrationCollector>()), Times.Once);
-        public void TestRegister() => Assert.DoesNotThrow(() => _iocContainer.Register(r => r.Add<ITest, Test>()));
+        installer2Mock.Verify(m => m.Install(It.IsAny<IRegistrationCollector>()), Times.Once);
+        installer3Mock.Verify(m => m.Install(It.IsAny<IRegistrationCollector>()), Times.Once);
 
-        [Test]
+        Assert.AreEqual(_iocContainer, returnedContainer);
-        public void TestRegisterTypeWithoutInterface() => Assert.DoesNotThrow(() => _iocContainer.Register(r => r.Add<Test>()));
+    }
 
-        [Test]
+    [Test]
-        public void TestRegisterMultiton() => Assert.DoesNotThrow(() => _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>()));
+    public void TestRegister() => Assert.DoesNotThrow(() => _iocContainer.Register(r => r.Add<ITest, Test>()));
 
-        [Test]
+    [Test]
-        public void TestInvalidMultitonRegistration() => Assert.Throws<InvalidRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, Test>(Lifestyle.Multiton)));
+    public void TestRegisterTypeWithoutInterface() => Assert.DoesNotThrow(() => _iocContainer.Register(r => r.Add<Test>()));
 
-        [Test]
+    [Test]
-        public void TestRegisterMultipleDifferent()
+    public void TestRegisterMultiton() => Assert.DoesNotThrow(() => _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>()));
-        {
-            _iocContainer.Register(r => r.Add<ITest, Test>());
-            MultipleRegistrationException exception = Assert.Throws<MultipleRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, TestConstructor>()));
-            Assert.AreEqual(typeof(ITest), exception?.Type);
-        }
 
-        [Test]
+    [Test]
-        public void TestRegisterMultipleSame()
+    public void TestInvalidMultitonRegistration() => Assert.Throws<InvalidRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, Test>(Lifestyle.Multiton)));
-        {
-            _iocContainer.Register(r => r.Add<ITest, Test>());
-            Assert.DoesNotThrow(() => _iocContainer.Register(r => r.Add<ITest, Test>()));
-        }
 
-        [Test]
+    [Test]
-        public void TestRegisterMultipleSameWithParameters()
+    public void TestRegisterMultipleDifferent()
-        {
+    {
-            _iocContainer.Register(r => r.Add<ITest, Test>().WithParameters("test", 1, new Foo()));
+        _iocContainer.Register(r => r.Add<ITest, Test>());
-            Assert.DoesNotThrow(() => _iocContainer.Register(r => r.Add<ITest, Test>().WithParameters("test", 1, new Foo())));
+        MultipleRegistrationException exception = Assert.Throws<MultipleRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, TestConstructor>()));
-        }
+        Assert.AreEqual(typeof(ITest), exception?.Type);
+    }
         
-        [Test]
+    [Test]
-        public void TestResolveNotRegistered()
+    public void TestRegisterMultipleSame()
-        {
+    {
-            TypeNotRegisteredException exception = Assert.Throws<TypeNotRegisteredException>(() => _iocContainer.Resolve<ITest>());
+        _iocContainer.Register(r => r.Add<ITest, Test>());
-            Assert.AreEqual(typeof(ITest), exception?.Type);
+        Assert.DoesNotThrow(() => _iocContainer.Register(r => r.Add<ITest, Test>()));
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestResolve()
+    public void TestRegisterMultipleSameWithParameters()
-        {
+    {
-            _iocContainer.Register(r => r.Add<ITest, Test>());
+        _iocContainer.Register(r => r.Add<ITest, Test>().WithParameters("test", 1, new Foo()));
+        Assert.DoesNotThrow(() => _iocContainer.Register(r => r.Add<ITest, Test>().WithParameters("test", 1, new Foo())));
+    }
         
-            ITest resolvedTest = _iocContainer.Resolve<ITest>();
+    [Test]
+    public void TestResolveNotRegistered()
+    {
+        TypeNotRegisteredException exception = Assert.Throws<TypeNotRegisteredException>(() => _iocContainer.Resolve<ITest>());
+        Assert.AreEqual(typeof(ITest), exception?.Type);
+    }
 
-            Assert.IsInstanceOf<Test>(resolvedTest);
+    [Test]
-        }
+    public void TestResolve()
+    {
+        _iocContainer.Register(r => r.Add<ITest, Test>());
 
-        [Test]
+        ITest resolvedTest = _iocContainer.Resolve<ITest>();
-        public void TestResolveWithoutInterface()
-        {
-            _iocContainer.Register(r => r.Add<Test>());
 
-            Test resolvedTest = _iocContainer.Resolve<Test>();
+        Assert.IsInstanceOf<Test>(resolvedTest);
+    }
 
-            Assert.IsInstanceOf<Test>(resolvedTest);
+    [Test]
-        }
+    public void TestResolveWithoutInterface()
+    {
+        _iocContainer.Register(r => r.Add<Test>());
 
-        [Test]
+        Test resolvedTest = _iocContainer.Resolve<Test>();
-        public void TestResolveInterfaceWithoutImplementation()
-        {
-            _iocContainer.Register(r => r.Add<ITest>());
-            Assert.Throws<InvalidRegistrationException>(() => _iocContainer.Resolve<ITest>());
-        }
 
-        [Test]
+        Assert.IsInstanceOf<Test>(resolvedTest);
-        public void TestResolveImplementationRegisteredWithInterface()
+    }
-        {
-            _iocContainer.Register(r => r.Add<ITest, Test>());
 
-            Test resolvedTest = _iocContainer.Resolve<Test>();
+    [Test]
+    public void TestResolveInterfaceWithoutImplementation()
+    {
+        _iocContainer.Register(r => r.Add<ITest>());
+        Assert.Throws<InvalidRegistrationException>(() => _iocContainer.Resolve<ITest>());
+    }
         
-            Assert.IsInstanceOf<Test>(resolvedTest);
+    [Test]
-        }
+    public void TestResolveImplementationRegisteredWithInterface()
+    {
+        _iocContainer.Register(r => r.Add<ITest, Test>());
 
-        [Test]
+        Test resolvedTest = _iocContainer.Resolve<Test>();
-        public void TestResolveWithParams()
-        {
-            _iocContainer.Register(r => r.Add<ITest, TestConstructor>());
             
-            ITest resolvedTest = _iocContainer.Resolve<ITest>("Test", new Test());
+        Assert.IsInstanceOf<Test>(resolvedTest);
+    }
 
-            Assert.IsInstanceOf<TestConstructor>(resolvedTest);
+    [Test]
-        }
+    public void TestResolveWithParams()
+    {
+        _iocContainer.Register(r => r.Add<ITest, TestConstructor>());
 
-        [Test]
+        ITest resolvedTest = _iocContainer.Resolve<ITest>("Test", new Test());
-        public void TestResolveWithMissingParam()
-        {
-            _iocContainer.Register(r => r.Add<ITest, TestConstructor>());
-            _iocContainer.Register(r => r.Add<Test, Test>()); //this registration is abnormal and should only be used in unit tests
 
-            ITest resolvedTest = _iocContainer.Resolve<ITest>("Test");
+        Assert.IsInstanceOf<TestConstructor>(resolvedTest);
+    }
 
-            Assert.IsInstanceOf<TestConstructor>(resolvedTest);
+    [Test]
-        }
+    public void TestResolveWithMissingParam()
+    {
+        _iocContainer.Register(r => r.Add<ITest, TestConstructor>());
+        _iocContainer.Register(r => r.Add<Test, Test>()); //this registration is abnormal and should only be used in unit tests
 
-        [Test]
+        ITest resolvedTest = _iocContainer.Resolve<ITest>("Test");
-        public void TestResolveSingleton()
-        {
-            _iocContainer.Register(r => r.Add<ITest, Test>(Lifestyle.Singleton));
 
-            ITest resolvedTest = _iocContainer.Resolve<ITest>();
+        Assert.IsInstanceOf<TestConstructor>(resolvedTest);
-            ITest secondResolvedTest = _iocContainer.Resolve<ITest>();
+    }
 
-            Assert.AreEqual(resolvedTest, secondResolvedTest);
+    [Test]
-        }
+    public void TestResolveSingleton()
+    {
+        _iocContainer.Register(r => r.Add<ITest, Test>(Lifestyle.Singleton));
 
-        [Test]
+        ITest resolvedTest = _iocContainer.Resolve<ITest>();
-        public void TestResolveMultiton()
+        ITest secondResolvedTest = _iocContainer.Resolve<ITest>();
-        {
-            _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>());
 
-            MultitonScope scope1 = new();
+        Assert.AreEqual(resolvedTest, secondResolvedTest);
-            MultitonScope scope2 = new();
+    }
 
-            ITest resolvedTest1 = _iocContainer.Resolve<ITest>(scope1);
+    [Test]
-            ITest resolvedTest2 = _iocContainer.Resolve<ITest>(scope1);
+    public void TestResolveMultiton()
-            ITest resolvedTest3 = _iocContainer.Resolve<ITest>(scope2);
+    {
+        _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>());
 
-            Assert.AreSame(resolvedTest1, resolvedTest2);
+        MultitonScope scope1 = new();
-            Assert.AreNotSame(resolvedTest1, resolvedTest3);
+        MultitonScope scope2 = new();
-            Assert.AreNotSame(resolvedTest2, resolvedTest3);
-        }
 
-        [Test]
+        ITest resolvedTest1 = _iocContainer.Resolve<ITest>(scope1);
-        public void TestResolveMultitonNoArgs()
+        ITest resolvedTest2 = _iocContainer.Resolve<ITest>(scope1);
-        {
+        ITest resolvedTest3 = _iocContainer.Resolve<ITest>(scope2);
-            _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>());
 
-            MultitonResolveException exception = Assert.Throws<MultitonResolveException>(() => _iocContainer.Resolve<ITest>());
+        Assert.AreSame(resolvedTest1, resolvedTest2);
-            Assert.AreEqual(typeof(ITest), exception?.Type);
+        Assert.AreNotSame(resolvedTest1, resolvedTest3);
-        }
+        Assert.AreNotSame(resolvedTest2, resolvedTest3);
+    }
 
-        [Test]
+    [Test]
-        public void TestResolveMultitonWrongArgs()
+    public void TestResolveMultitonNoArgs()
-        {
+    {
-            _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>());
+        _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>());
 
-            MultitonResolveException exception = Assert.Throws<MultitonResolveException>(() => _iocContainer.Resolve<ITest>(new object()));
+        MultitonResolveException exception = Assert.Throws<MultitonResolveException>(() => _iocContainer.Resolve<ITest>());
-            Assert.AreEqual(typeof(ITest), exception?.Type);
+        Assert.AreEqual(typeof(ITest), exception?.Type);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestResolveTransient()
+    public void TestResolveMultitonWrongArgs()
-        {
+    {
-            _iocContainer.Register(r => r.Add<ITest, Test>());
+        _iocContainer.Register(r => r.AddMultiton<ITest, Test, MultitonScope>());
 
-            ITest resolvedTest = _iocContainer.Resolve<ITest>();
+        MultitonResolveException exception = Assert.Throws<MultitonResolveException>(() => _iocContainer.Resolve<ITest>(new object()));
-            ITest secondResolvedTest = _iocContainer.Resolve<ITest>();
+        Assert.AreEqual(typeof(ITest), exception?.Type);
+    }
 
-            Assert.AreNotEqual(resolvedTest, secondResolvedTest);
+    [Test]
-        }
+    public void TestResolveTransient()
+    {
+        _iocContainer.Register(r => r.Add<ITest, Test>());
 
-        [Test]
+        ITest resolvedTest = _iocContainer.Resolve<ITest>();
-        public void TestResolveNoMatchingConstructor()
+        ITest secondResolvedTest = _iocContainer.Resolve<ITest>();
-        {
-            _iocContainer.Register(r => r.Add<ITest, TestConstructor>());
-            NoMatchingConstructorFoundException exception = Assert.Throws<NoMatchingConstructorFoundException>(() => _iocContainer.Resolve<ITest>());
-            Assert.AreEqual(typeof(TestConstructor), exception?.Type);
-        }
 
-        [Test]
+        Assert.AreNotEqual(resolvedTest, secondResolvedTest);
-        public void TestResolveNoMatchingConstructorNotThrownWrongly()
+    }
-        {
-            _iocContainer.Register(r => r.Add<ITest, TestMultipleConstructors>());
-            Assert.DoesNotThrow(() => _iocContainer.Resolve<ITest>("Name"));
-        }
 
-        [Test]
+    [Test]
-        public void TestResolvePrivateConstructor()
+    public void TestResolveNoMatchingConstructor()
-        {
+    {
-            _iocContainer.Register(r => r.Add<ITest, TestPrivateConstructor>());
+        _iocContainer.Register(r => r.Add<ITest, TestConstructor>());
-            NoPublicConstructorFoundException exception = Assert.Throws<NoPublicConstructorFoundException>(() => _iocContainer.Resolve<ITest>());
+        NoMatchingConstructorFoundException exception = Assert.Throws<NoMatchingConstructorFoundException>(() => _iocContainer.Resolve<ITest>());
-            Assert.AreEqual(typeof(TestPrivateConstructor), exception?.Type);
+        Assert.AreEqual(typeof(TestConstructor), exception?.Type);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestResolveSingleTypeRegistrationWithFactoryMethod()
+    public void TestResolveNoMatchingConstructorNotThrownWrongly()
-        {
+    {
-            _iocContainer.Register(r => r.Add<IFoo, Foo>());
+        _iocContainer.Register(r => r.Add<ITest, TestMultipleConstructors>());
-            _iocContainer.Register(r => r.Add<ITest>().WithFactoryMethod(c => new TestConstructor(c.Resolve<IFoo>(), "someName")));
+        Assert.DoesNotThrow(() => _iocContainer.Resolve<ITest>("Name"));
+    }
 
-            ITest test = _iocContainer.Resolve<ITest>();
+    [Test]
+    public void TestResolvePrivateConstructor()
+    {
+        _iocContainer.Register(r => r.Add<ITest, TestPrivateConstructor>());
+        NoPublicConstructorFoundException exception = Assert.Throws<NoPublicConstructorFoundException>(() => _iocContainer.Resolve<ITest>());
+        Assert.AreEqual(typeof(TestPrivateConstructor), exception?.Type);
+    }
 
-            Assert.NotNull(test);
+    [Test]
-        }
+    public void TestResolveSingleTypeRegistrationWithFactoryMethod()
+    {
+        _iocContainer.Register(r => r.Add<IFoo, Foo>());
+        _iocContainer.Register(r => r.Add<ITest>().WithFactoryMethod(c => new TestConstructor(c.Resolve<IFoo>(), "someName")));
 
-        [Test]
+        ITest test = _iocContainer.Resolve<ITest>();
-        public void TestResolveParameterIsRegisteredWithParameters()
+            
-        {
+        Assert.NotNull(test);
-            _iocContainer.Register(r => r.Add<ITest, TestConstructor>());
+    }
-            _iocContainer.Register(r => r.Add<IFoo, FooConstructor>().WithParameters("TestString"));
 
-            ITest test = _iocContainer.Resolve<ITest>("testName");
+    [Test]
+    public void TestResolveParameterIsRegisteredWithParameters()
+    {
+        _iocContainer.Register(r => r.Add<ITest, TestConstructor>());
+        _iocContainer.Register(r => r.Add<IFoo, FooConstructor>().WithParameters("TestString"));
 
-            Assert.IsInstanceOf<TestConstructor>(test);
+        ITest test = _iocContainer.Resolve<ITest>("testName");
-        }
             
-        [Test]
+        Assert.IsInstanceOf<TestConstructor>(test);
-        public void TestResolveParameterWithParameterThatIsAlreadyExistingSingleton()
+    }
-        {
-            _iocContainer.Register(r => r.Add<ITest, TestWithFoo>());
-            _iocContainer.Register(r => r.Add<IFoo, FooConstructor>(Lifestyle.Singleton).WithParameters("TestString"));
 
-            IFoo foo = _iocContainer.Resolve<IFoo>();
+    [Test]
-            ITest test = _iocContainer.Resolve<ITest>("testName");
+    public void TestResolveParameterWithParameterThatIsAlreadyExistingSingleton()
+    {
+        _iocContainer.Register(r => r.Add<ITest, TestWithFoo>());
+        _iocContainer.Register(r => r.Add<IFoo, FooConstructor>(Lifestyle.Singleton).WithParameters("TestString"));
 
-            Assert.IsInstanceOf<TestWithFoo>(test);
+        IFoo foo = _iocContainer.Resolve<IFoo>();
-            Assert.AreSame(foo, ((TestWithFoo) test).TestFoo);
+        ITest test = _iocContainer.Resolve<ITest>("testName");
-        }
             
-        [Test]
+        Assert.IsInstanceOf<TestWithFoo>(test);
-        public void TestIsTypeRegistered()
+        Assert.AreSame(foo, ((TestWithFoo) test).TestFoo);
-        {
+    }
-            Assert.False(_iocContainer.IsTypeRegistered<ITest>());
+
+    [Test]
+    public void TestIsTypeRegistered()
+    {
+        Assert.False(_iocContainer.IsTypeRegistered<ITest>());
 
-            _iocContainer.Register(r => r.Add<ITest, Test>());
+        _iocContainer.Register(r => r.Add<ITest, Test>());
-            Assert.True(_iocContainer.IsTypeRegistered<ITest>());
+        Assert.True(_iocContainer.IsTypeRegistered<ITest>());
 
-            _iocContainer.Register(r => r.Add<Test>());
+        _iocContainer.Register(r => r.Add<Test>());
-            Assert.True(_iocContainer.IsTypeRegistered<Test>());
+        Assert.True(_iocContainer.IsTypeRegistered<Test>());
-        }
     }
 }

Test.LightweightIocContainer/IocValidatorTest.cs

@@ -12,177 +12,176 @@ using LightweightIocContainer.Validation;
 using Moq;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class IocValidatorTest
 {
-    [TestFixture]
+    public interface ITest
-    public class IocValidatorTest
     {
-        public interface ITest
-        {
             
-        }
+    }
         
-        public interface ITest2
+    public interface ITest2
-        {
+    {
             
-        }
+    }
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface IParameter
+    public interface IParameter
-        {
+    {
-            bool Method();
+        bool Method();
-        }
+    }
 
-        private class Test : ITest
+    private class Test : ITest
-        {
+    {
-            public Test(IParameter parameter) => parameter.Method();
+        public Test(IParameter parameter) => parameter.Method();
-        }
+    }
         
         
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface ITestFactory
+    public interface ITestFactory
-        {
+    {
-            ITest Create(IParameter parameter);
+        ITest Create(IParameter parameter);
-        }
+    }
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface ITest2Factory
+    public interface ITest2Factory
-        {
+    {
-            ITest2 InvalidCreate();
+        ITest2 InvalidCreate();
-            ITest2 Create(ITest test);
+        ITest2 Create(ITest test);
-        }
+    }
 
 
-        private class Test2 : ITest2
+    private class Test2 : ITest2
+    {
+        public Test2(ITest parameter)
         {
-            public Test2(ITest parameter)
-            {
                 
-            }
         }
+    }
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface IInvalidFactory
+    public interface IInvalidFactory
-        {
+    {
-            ITest Create();
+        ITest Create();
-        }
+    }
         
-        private class TestInstallerNoFactory : IIocInstaller
+    private class TestInstallerNoFactory : IIocInstaller
-        {
+    {
-            public void Install(IRegistrationCollector registration) => registration.Add<ITest, Test>();
+        public void Install(IRegistrationCollector registration) => registration.Add<ITest, Test>();
-        }
+    }
         
-        private class TestInstallerWithFactory : IIocInstaller
+    private class TestInstallerWithFactory : IIocInstaller
-        {
+    {
-            public void Install(IRegistrationCollector registration) => registration.Add<ITest, Test>().WithFactory<ITestFactory>();
+        public void Install(IRegistrationCollector registration) => registration.Add<ITest, Test>().WithFactory<ITestFactory>();
-        }
+    }
         
-        private class TestInstallerWithInvalidFactory : IIocInstaller
+    private class TestInstallerWithInvalidFactory : IIocInstaller
-        {
+    {
-            public void Install(IRegistrationCollector registration) => registration.Add<ITest, Test>().WithFactory<IInvalidFactory>();
+        public void Install(IRegistrationCollector registration) => registration.Add<ITest, Test>().WithFactory<IInvalidFactory>();
-        }
+    }
         
-        private class InvalidTestClassInstaller : IIocInstaller
+    private class InvalidTestClassInstaller : IIocInstaller
+    {
+        public void Install(IRegistrationCollector registration)
         {
-            public void Install(IRegistrationCollector registration)
+            registration.Add<ITest, Test>().WithFactory<ITestFactory>();
-            {
+            registration.Add<ITest2, Test2>().WithFactory<ITest2Factory>();
-                registration.Add<ITest, Test>().WithFactory<ITestFactory>();
-                registration.Add<ITest2, Test2>().WithFactory<ITest2Factory>();
-            }
         }
+    }
         
-        [Test]
+    [Test]
-        public void TestValidateWithoutFactory()
+    public void TestValidateWithoutFactory()
-        {
+    {
-            IocContainer iocContainer = new();
+        IocContainer iocContainer = new();
-            iocContainer.Install(new TestInstallerNoFactory());
+        iocContainer.Install(new TestInstallerNoFactory());
-            
-            IocValidator validator = new(iocContainer);
             
-            AggregateException aggregateException = Assert.Throws<AggregateException>(() => validator.Validate());
+        IocValidator validator = new(iocContainer);
             
-            AssertNoMatchingConstructorFoundForType<Test>(aggregateException);
+        AggregateException aggregateException = Assert.Throws<AggregateException>(() => validator.Validate());
-        }
-        
-        [Test]
-        public void TestValidateWithFactory()
-        {
-            IocContainer iocContainer = new();
-            iocContainer.Install(new TestInstallerWithFactory());
             
-            IocValidator validator = new(iocContainer);
+        AssertNoMatchingConstructorFoundForType<Test>(aggregateException);
+    }
         
-            validator.Validate();
+    [Test]
-        }
+    public void TestValidateWithFactory()
+    {
+        IocContainer iocContainer = new();
+        iocContainer.Install(new TestInstallerWithFactory());
             
-        [Test]
+        IocValidator validator = new(iocContainer);
-        public void TestValidateWithParameter()
-        {
-            IocContainer iocContainer = new();
-            iocContainer.Install(new TestInstallerNoFactory());
             
-            IocValidator validator = new(iocContainer);
+        validator.Validate();
+    }
         
-            Mock<IParameter> parameterMock = new();
+    [Test]
-            parameterMock.Setup(p => p.Method()).Returns(true);
+    public void TestValidateWithParameter()
+    {
+        IocContainer iocContainer = new();
+        iocContainer.Install(new TestInstallerNoFactory());
             
-            validator.AddParameter<ITest, IParameter>(parameterMock.Object);
+        IocValidator validator = new(iocContainer);
 
-            validator.Validate();
+        Mock<IParameter> parameterMock = new();
+        parameterMock.Setup(p => p.Method()).Returns(true);
 
-            parameterMock.Verify(p => p.Method(), Times.Never);
+        validator.AddParameter<ITest, IParameter>(parameterMock.Object);
-        }
             
+        validator.Validate();
             
-        [Test]
+        parameterMock.Verify(p => p.Method(), Times.Never);
-        public void TestValidateWithInvalidParameterWithFactory()
+    }
-        {
-            IocContainer iocContainer = new();
-            iocContainer.Install(new InvalidTestClassInstaller());
         
-            IocValidator validator = new(iocContainer);
            
-            Mock<IParameter> parameterMock = new();
+    [Test]
-            validator.AddParameter<ITest, IParameter>(parameterMock.Object);
+    public void TestValidateWithInvalidParameterWithFactory()
+    {
+        IocContainer iocContainer = new();
+        iocContainer.Install(new InvalidTestClassInstaller());
             
-            AggregateException aggregateException = Assert.Throws<AggregateException>(() => validator.Validate());
+        IocValidator validator = new(iocContainer);
 
-            if (aggregateException?.InnerExceptions[0] is not NoMatchingConstructorFoundException noMatchingConstructorFoundException)
+        Mock<IParameter> parameterMock = new();
-            {
+        validator.AddParameter<ITest, IParameter>(parameterMock.Object);
-                Assert.Fail();
-                return;
-            }
             
-            if (noMatchingConstructorFoundException.InnerExceptions[0] is not ConstructorNotMatchingException iTest2CtorNotMatchingException)
+        AggregateException aggregateException = Assert.Throws<AggregateException>(() => validator.Validate());
-            {
-                Assert.Fail();
-                return;
-            }
 
-            Assert.IsInstanceOf<DirectResolveWithRegisteredFactoryNotAllowed>(iTest2CtorNotMatchingException.InnerExceptions[0]);
+        if (aggregateException?.InnerExceptions[0] is not NoMatchingConstructorFoundException noMatchingConstructorFoundException)
+        {
+            Assert.Fail();
+            return;
         }
             
-        [Test]
+        if (noMatchingConstructorFoundException.InnerExceptions[0] is not ConstructorNotMatchingException iTest2CtorNotMatchingException)
-        public void TestValidateInvalidFactory()
         {
-            IocContainer iocContainer = new();
+            Assert.Fail();
-            iocContainer.Install(new TestInstallerWithInvalidFactory());
+            return;
+        }
             
-            IocValidator validator = new(iocContainer);
+        Assert.IsInstanceOf<DirectResolveWithRegisteredFactoryNotAllowed>(iTest2CtorNotMatchingException.InnerExceptions[0]);
+    }
         
-            AggregateException aggregateException = Assert.Throws<AggregateException>(() => validator.Validate());
+    [Test]
+    public void TestValidateInvalidFactory()
+    {
+        IocContainer iocContainer = new();
+        iocContainer.Install(new TestInstallerWithInvalidFactory());
             
-            AssertNoMatchingConstructorFoundForType<Test>(aggregateException);
+        IocValidator validator = new(iocContainer);
-        }
             
-        private void AssertNoMatchingConstructorFoundForType<T>(AggregateException aggregateException)
+        AggregateException aggregateException = Assert.Throws<AggregateException>(() => validator.Validate());
-        {
+            
-            Exception exception = aggregateException?.InnerExceptions[0];
+        AssertNoMatchingConstructorFoundForType<Test>(aggregateException);
-            if (exception is NoMatchingConstructorFoundException noMatchingConstructorFoundException)
+    }
-                Assert.AreEqual(typeof(T), noMatchingConstructorFoundException.Type);
+
-            else
+    private void AssertNoMatchingConstructorFoundForType<T>(AggregateException aggregateException)
-                Assert.Fail($"Exception is no NoMatchingConstructorFoundException, actual type: {exception?.GetType()}");
+    {
-        }
+        Exception exception = aggregateException?.InnerExceptions[0];
+        if (exception is NoMatchingConstructorFoundException noMatchingConstructorFoundException)
+            Assert.AreEqual(typeof(T), noMatchingConstructorFoundException.Type);
+        else
+            Assert.Fail($"Exception is no NoMatchingConstructorFoundException, actual type: {exception?.GetType()}");
     }
 }

Test.LightweightIocContainer/MultipleMultitonRegistrationTest.cs

@@ -6,96 +6,95 @@ using JetBrains.Annotations;
 using LightweightIocContainer;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class MultipleMultitonRegistrationTest
 {
-    [TestFixture]
+    private IocContainer _iocContainer;
-    public class MultipleMultitonRegistrationTest
-    {
-        private IocContainer _iocContainer;
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public interface ITest : IProvider
+    public interface ITest : IProvider
-        {
+    {
             
-        }
+    }
         
-        public interface IProvider
+    public interface IProvider
-        {
+    {
-            int Number { get; }
+        int Number { get; }
-            void DoSomething(int number);
+        void DoSomething(int number);
-        }
+    }
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public class Test : ITest
+    public class Test : ITest
-        {
+    {
-            public int Number { get; private set; }
+        public int Number { get; private set; }
 
-            public void DoSomething(int number) => Number = number;
+        public void DoSomething(int number) => Number = number;
-        }
+    }
 
-        private class MultitonScope
+    private class MultitonScope
-        {
+    {
             
-        }
+    }
         
         
-        [SetUp]
+    [SetUp]
-        public void SetUp() => _iocContainer = new IocContainer();
+    public void SetUp() => _iocContainer = new IocContainer();
 
-        [TearDown]
+    [TearDown]
-        public void TearDown() => _iocContainer.Dispose();
+    public void TearDown() => _iocContainer.Dispose();
 
-        [Test]
+    [Test]
-        public void TestRegisterAndResolveMultipleMultitonRegistration()
+    public void TestRegisterAndResolveMultipleMultitonRegistration()
-        {
+    {
-            _iocContainer.Register(r => r.AddMultiton<IProvider, ITest, Test, MultitonScope>());
+        _iocContainer.Register(r => r.AddMultiton<IProvider, ITest, Test, MultitonScope>());
 
-            MultitonScope scope = new();
+        MultitonScope scope = new();
             
-            ITest test = _iocContainer.Resolve<ITest>(scope);
+        ITest test = _iocContainer.Resolve<ITest>(scope);
-            Assert.NotNull(test);
+        Assert.NotNull(test);
 
-            IProvider provider = _iocContainer.Resolve<IProvider>(scope);
+        IProvider provider = _iocContainer.Resolve<IProvider>(scope);
-            Assert.NotNull(provider);
+        Assert.NotNull(provider);
-            Assert.AreEqual(test, provider);
+        Assert.AreEqual(test, provider);
-            Assert.AreSame(test, provider);
+        Assert.AreSame(test, provider);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestRegisterAndResolveMultipleMultitonRegistrationWithDifferentScope()
+    public void TestRegisterAndResolveMultipleMultitonRegistrationWithDifferentScope()
-        {
+    {
-            _iocContainer.Register(r => r.AddMultiton<IProvider, ITest, Test, MultitonScope>());
+        _iocContainer.Register(r => r.AddMultiton<IProvider, ITest, Test, MultitonScope>());
 
-            MultitonScope scope = new();
+        MultitonScope scope = new();
-            MultitonScope differentScope = new();
+        MultitonScope differentScope = new();
             
-            ITest test = _iocContainer.Resolve<ITest>(scope);
+        ITest test = _iocContainer.Resolve<ITest>(scope);
-            Assert.NotNull(test);
+        Assert.NotNull(test);
 
-            IProvider provider = _iocContainer.Resolve<IProvider>(differentScope);
+        IProvider provider = _iocContainer.Resolve<IProvider>(differentScope);
-            Assert.NotNull(provider);
+        Assert.NotNull(provider);
             
-            Assert.AreNotEqual(test, provider);
+        Assert.AreNotEqual(test, provider);
-            Assert.AreNotSame(test, provider);
+        Assert.AreNotSame(test, provider);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestMultipleMultitonRegistrationOnCreate()
+    public void TestMultipleMultitonRegistrationOnCreate()
-        {
+    {
-            _iocContainer.Register(r => r.AddMultiton<IProvider, ITest, Test, MultitonScope>().OnCreate(t => t.DoSomething(1)));
+        _iocContainer.Register(r => r.AddMultiton<IProvider, ITest, Test, MultitonScope>().OnCreate(t => t.DoSomething(1)));
             
-            MultitonScope scope = new();
+        MultitonScope scope = new();
             
-            ITest test = _iocContainer.Resolve<ITest>(scope);
+        ITest test = _iocContainer.Resolve<ITest>(scope);
-            Assert.NotNull(test);
+        Assert.NotNull(test);
-            Assert.AreEqual(1, test.Number);
+        Assert.AreEqual(1, test.Number);
 
-            IProvider provider = _iocContainer.Resolve<IProvider>(scope);
+        IProvider provider = _iocContainer.Resolve<IProvider>(scope);
-            Assert.NotNull(provider);
+        Assert.NotNull(provider);
-            Assert.AreEqual(1, provider.Number);
+        Assert.AreEqual(1, provider.Number);
             
-            Assert.AreEqual(test, provider);
+        Assert.AreEqual(test, provider);
-            Assert.AreSame(test, provider);
+        Assert.AreSame(test, provider);
-        }
     }
 }

Test.LightweightIocContainer/OnCreateTest.cs

@@ -9,31 +9,30 @@ using LightweightIocContainer.Registrations;
 using Moq;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class OnCreateTest
 {
-    [TestFixture]
+    private interface ITest
-    public class OnCreateTest
     {
-        private interface ITest
+        void DoSomething();
-        {
+    }
-            void DoSomething();
-        }
 
-        private class Test : ITest
+    private class Test : ITest
-        {
+    {
-            public void DoSomething() => throw new Exception();
+        public void DoSomething() => throw new Exception();
-        }
+    }
 
         
-        [Test]
+    [Test]
-        public void TestOnCreate()
+    public void TestOnCreate()
-        {
+    {
-            RegistrationFactory registrationFactory = new(new Mock<IocContainer>().Object);
+        RegistrationFactory registrationFactory = new(new Mock<IocContainer>().Object);
-            ITypedRegistration<ITest, Test> testRegistration = registrationFactory.Register<ITest, Test>(Lifestyle.Transient).OnCreate(t => t.DoSomething());
+        ITypedRegistration<ITest, Test> testRegistration = registrationFactory.Register<ITest, Test>(Lifestyle.Transient).OnCreate(t => t.DoSomething());
 
-            Test test = new();
+        Test test = new();
 
-            Assert.Throws<Exception>(() => testRegistration.OnCreateAction!(test));
+        Assert.Throws<Exception>(() => testRegistration.OnCreateAction!(test));
-        }
     }
 }

Test.LightweightIocContainer/OpenGenericRegistrationTest.cs

@@ -8,62 +8,61 @@ using LightweightIocContainer;
 using LightweightIocContainer.Exceptions;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class OpenGenericRegistrationTest
 {
-    [TestFixture]
+    private IocContainer _iocContainer;
-    public class OpenGenericRegistrationTest
-    {
-        private IocContainer _iocContainer;
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        [SuppressMessage("ReSharper", "UnusedTypeParameter")]
+    [SuppressMessage("ReSharper", "UnusedTypeParameter")]
-        public interface ITest<T>
+    public interface ITest<T>
-        {
+    {
             
-        }
+    }
         
-        [UsedImplicitly]
+    [UsedImplicitly]
-        public class Test<T> : ITest<T>
+    public class Test<T> : ITest<T>
-        {
+    {
             
-        }
+    }
 
-        [SetUp]
+    [SetUp]
-        public void SetUp() => _iocContainer = new IocContainer();
+    public void SetUp() => _iocContainer = new IocContainer();
 
-        [TearDown]
+    [TearDown]
-        public void TearDown() => _iocContainer.Dispose();
+    public void TearDown() => _iocContainer.Dispose();
 
-        [Test]
+    [Test]
-        public void TestRegisterOpenGenericType()
+    public void TestRegisterOpenGenericType()
-        {
+    {
-            _iocContainer.Register(r => r.AddOpenGenerics(typeof(ITest<>), typeof(Test<>)));
+        _iocContainer.Register(r => r.AddOpenGenerics(typeof(ITest<>), typeof(Test<>)));
 
-            ITest<int> test = _iocContainer.Resolve<ITest<int>>();
+        ITest<int> test = _iocContainer.Resolve<ITest<int>>();
-            Assert.NotNull(test);
+        Assert.NotNull(test);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestRegisterOpenGenericTypeAsSingleton()
+    public void TestRegisterOpenGenericTypeAsSingleton()
-        {
+    {
-            _iocContainer.Register(r => r.AddOpenGenerics(typeof(ITest<>), typeof(Test<>), Lifestyle.Singleton));
+        _iocContainer.Register(r => r.AddOpenGenerics(typeof(ITest<>), typeof(Test<>), Lifestyle.Singleton));
 
-            ITest<int> test = _iocContainer.Resolve<ITest<int>>();
+        ITest<int> test = _iocContainer.Resolve<ITest<int>>();
-            Assert.NotNull(test);
+        Assert.NotNull(test);
 
-            ITest<int> secondTest = _iocContainer.Resolve<ITest<int>>();
+        ITest<int> secondTest = _iocContainer.Resolve<ITest<int>>();
-            Assert.NotNull(secondTest);
+        Assert.NotNull(secondTest);
             
-            Assert.AreEqual(test, secondTest);
+        Assert.AreEqual(test, secondTest);
-            Assert.AreSame(test, secondTest);
+        Assert.AreSame(test, secondTest);
-        }
+    }
         
-        [Test]
+    [Test]
-        public void TestRegisterOpenGenericTypeAsMultitonThrowsException() => 
+    public void TestRegisterOpenGenericTypeAsMultitonThrowsException() => 
-            Assert.Throws<InvalidRegistrationException>(() => _iocContainer.Register(r => r.AddOpenGenerics(typeof(ITest<>), typeof(Test<>), Lifestyle.Multiton)));
+        Assert.Throws<InvalidRegistrationException>(() => _iocContainer.Register(r => r.AddOpenGenerics(typeof(ITest<>), typeof(Test<>), Lifestyle.Multiton)));
 
-        [Test]
+    [Test]
-        public void TestRegisterNonOpenGenericTypeWithOpenGenericsFunctionThrowsException() =>
+    public void TestRegisterNonOpenGenericTypeWithOpenGenericsFunctionThrowsException() =>
-            Assert.Throws<InvalidRegistrationException>(() => _iocContainer.Register(r => r.AddOpenGenerics(typeof(int), typeof(int))));
+        Assert.Throws<InvalidRegistrationException>(() => _iocContainer.Register(r => r.AddOpenGenerics(typeof(int), typeof(int))));
-    }
 }

Test.LightweightIocContainer/RegistrationBaseTest.cs

@@ -10,90 +10,89 @@ using LightweightIocContainer.ResolvePlaceholders;
 using Moq;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+public class RegistrationBaseTest
 {
-    [TestFixture]
+    private interface ITest
-    public class RegistrationBaseTest
     {
-        private interface ITest
-        {
 
-        }
+    }
 
-        private interface IFoo
+    private interface IFoo
-        {
+    {
 
-        }
+    }
 
-        private interface IBar
+    private interface IBar
-        {
+    {
 
-        }
+    }
 
-        private class Test : ITest
+    private class Test : ITest
-        {
+    {
 
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class Foo : IFoo
+    private class Foo : IFoo
+    {
+        public Foo(IBar bar, ITest test)
         {
-            public Foo(IBar bar, ITest test)
-            {
 
-            }
         }
+    }
 
-        private class Bar : IBar
+    private class Bar : IBar
-        {
+    {
 
-        }
+    }
 
 
-        [Test]
+    [Test]
-        public void TestWithParameters()
+    public void TestWithParameters()
-        {
+    {
-            RegistrationFactory registrationFactory = new(new Mock<IocContainer>().Object);
+        RegistrationFactory registrationFactory = new(new Mock<IocContainer>().Object);
 
-            IBar bar = new Bar();
+        IBar bar = new Bar();
-            ITest test = new Test();
+        ITest test = new Test();
 
-            RegistrationBase testRegistration = (RegistrationBase) registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters(bar, test);
+        RegistrationBase testRegistration = (RegistrationBase) registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters(bar, test);
 
-            Assert.AreEqual(bar, testRegistration.Parameters![0]);
+        Assert.AreEqual(bar, testRegistration.Parameters![0]);
-            Assert.AreEqual(test, testRegistration.Parameters[1]);
+        Assert.AreEqual(test, testRegistration.Parameters[1]);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestWithParametersDifferentOrder()
+    public void TestWithParametersDifferentOrder()
-        {
+    {
-            RegistrationFactory registrationFactory = new(new Mock<IocContainer>().Object);
+        RegistrationFactory registrationFactory = new(new Mock<IocContainer>().Object);
 
-            IBar bar = new Bar();
+        IBar bar = new Bar();
-            ITest test = new Test();
+        ITest test = new Test();
 
-            RegistrationBase testRegistration = (RegistrationBase) registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters((0, bar), (3, test), (2, "SomeString"));
+        RegistrationBase testRegistration = (RegistrationBase) registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters((0, bar), (3, test), (2, "SomeString"));
 
-            Assert.AreEqual(bar, testRegistration.Parameters![0]);
+        Assert.AreEqual(bar, testRegistration.Parameters![0]);
-            Assert.IsInstanceOf<InternalResolvePlaceholder>(testRegistration.Parameters[1]);
+        Assert.IsInstanceOf<InternalResolvePlaceholder>(testRegistration.Parameters[1]);
-            Assert.AreEqual("SomeString", testRegistration.Parameters[2]);
+        Assert.AreEqual("SomeString", testRegistration.Parameters[2]);
-            Assert.AreEqual(test, testRegistration.Parameters[3]);
+        Assert.AreEqual(test, testRegistration.Parameters[3]);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestWithParametersCalledTwice()
+    public void TestWithParametersCalledTwice()
-        {
+    {
-            RegistrationFactory registrationFactory = new(new Mock<IocContainer>().Object);
+        RegistrationFactory registrationFactory = new(new Mock<IocContainer>().Object);
-            Assert.Throws<InvalidRegistrationException>(() => registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters(new Bar()).WithParameters(new Test()));
+        Assert.Throws<InvalidRegistrationException>(() => registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters(new Bar()).WithParameters(new Test()));
-            Assert.Throws<InvalidRegistrationException>(() => registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters((0, new Bar())).WithParameters((1, new Test())));
+        Assert.Throws<InvalidRegistrationException>(() => registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters((0, new Bar())).WithParameters((1, new Test())));
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestWithParametersNoParametersGiven()
+    public void TestWithParametersNoParametersGiven()
-        {
+    {
-            RegistrationFactory registrationFactory = new(new Mock<IocContainer>().Object);
+        RegistrationFactory registrationFactory = new(new Mock<IocContainer>().Object);
-            Assert.Throws<InvalidRegistrationException>(() => registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters((object[])null));
+        Assert.Throws<InvalidRegistrationException>(() => registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters((object[])null));
-            Assert.Throws<InvalidRegistrationException>(() => registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters(((int index, object parameter)[])null));
+        Assert.Throws<InvalidRegistrationException>(() => registrationFactory.Register<IFoo, Foo>(Lifestyle.Transient).WithParameters(((int index, object parameter)[])null));
-        }
     }
 }

Test.LightweightIocContainer/SingleTypeRegistrationTest.cs

@@ -9,63 +9,62 @@ using LightweightIocContainer.Registrations;
 using Moq;
 using NUnit.Framework;
 
-namespace Test.LightweightIocContainer
+namespace Test.LightweightIocContainer;
+
+[TestFixture]
+// ReSharper disable MemberHidesStaticFromOuterClass
+public class SingleTypeRegistrationTest
 {
-    [TestFixture]
+    private interface IFoo
-    // ReSharper disable MemberHidesStaticFromOuterClass
-    public class SingleTypeRegistrationTest
     {
-        private interface IFoo
+        IBar Bar { get; }
-        {
+    }
-            IBar Bar { get; }
-        }
 
-        private interface IBar
+    private interface IBar
-        {
+    {
             
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class Foo : IFoo
+    private class Foo : IFoo
-        {
+    {
-            public Foo(IBar bar) => Bar = bar;
+        public Foo(IBar bar) => Bar = bar;
 
-            public IBar Bar { get; }
+        public IBar Bar { get; }
-        }
+    }
 
-        [UsedImplicitly]
+    [UsedImplicitly]
-        private class Bar : IBar
+    private class Bar : IBar
-        {
+    {
             
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestSingleTypeRegistrationWithFactoryMethod()
+    public void TestSingleTypeRegistrationWithFactoryMethod()
-        {
+    {
-            IBar bar = new Bar();
+        IBar bar = new Bar();
 
-            Mock<IocContainer> iocContainerMock = new();
+        Mock<IocContainer> iocContainerMock = new();
-            iocContainerMock.Setup(c => c.Resolve<IBar>()).Returns(bar);
+        iocContainerMock.Setup(c => c.Resolve<IBar>()).Returns(bar);
 
-            RegistrationFactory registrationFactory = new(iocContainerMock.Object);
+        RegistrationFactory registrationFactory = new(iocContainerMock.Object);
-            ISingleTypeRegistration<IFoo> registration = registrationFactory.Register<IFoo>(Lifestyle.Transient).WithFactoryMethod(c => new Foo(c.Resolve<IBar>()));
+        ISingleTypeRegistration<IFoo> registration = registrationFactory.Register<IFoo>(Lifestyle.Transient).WithFactoryMethod(c => new Foo(c.Resolve<IBar>()));
 
-            IFoo foo = registration.FactoryMethod!(iocContainerMock.Object);
+        IFoo foo = registration.FactoryMethod!(iocContainerMock.Object);
-            Assert.AreEqual(bar, foo.Bar);
+        Assert.AreEqual(bar, foo.Bar);
-        }
+    }
 
-        [Test]
+    [Test]
-        public void TestSingleTypeRegistrationResolveSingleton()
+    public void TestSingleTypeRegistrationResolveSingleton()
-        {
+    {
-            IocContainer container = new();
+        IocContainer container = new();
 
-            IBar bar = new Bar();
+        IBar bar = new Bar();
-            container.Register(r => r.Add<IFoo>(Lifestyle.Singleton).WithFactoryMethod(_ => new Foo(bar)));
+        container.Register(r => r.Add<IFoo>(Lifestyle.Singleton).WithFactoryMethod(_ => new Foo(bar)));
 
-            IFoo foo = container.Resolve<IFoo>();
+        IFoo foo = container.Resolve<IFoo>();
 
-            Assert.IsInstanceOf<Foo>(foo);
+        Assert.IsInstanceOf<Foo>(foo);
-            Assert.AreEqual(bar, foo.Bar);
+        Assert.AreEqual(bar, foo.Bar);
-        }
     }
 }