- allow registration of same types if registered equally

LightweightIocContainer/Exceptions/MultipleRegistrationException.cs

@@ -8,16 +8,16 @@ using LightweightIocContainer.Interfaces;
 namespace LightweightIocContainer.Exceptions
 {
     /// <summary>
-    /// The <see cref="System.Type"/> is already registered in this <see cref="IIocContainer"/>
+    /// 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 in this <see cref="IIocContainer"/>
+        /// The <see cref="System.Type"/> is already registered differently in this <see cref="IIocContainer"/>
         /// </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 in this IocContainer.") =>
+            : base($"Type {type.Name} is already registered differently in this IocContainer.") =>
             Type = type;
 
         /// <summary>

LightweightIocContainer/IocContainer.cs

@@ -88,8 +88,8 @@ namespace LightweightIocContainer
         /// <exception cref="MultipleRegistrationException">The <see cref="Type"/> is already registered in this <see cref="IocContainer"/></exception>
         private void Register(IRegistration registration)
         {
-            //if type is already registered //fixMe: Remove and check if already registered registration is the same
+            IRegistration? sameTypeRegistration = Registrations.FirstOrDefault(r => r.InterfaceType == registration.InterfaceType);
-            if (Registrations.Any(r => r.InterfaceType == registration.InterfaceType))
+            if (sameTypeRegistration != null && !registration.Equals(sameTypeRegistration)) //if type is already registered differently
                 throw new MultipleRegistrationException(registration.InterfaceType);
 
             if (registration is IInternalValidationProvider validationProvider)

LightweightIocContainer/LightweightIocContainer.xml

@@ -234,12 +234,12 @@
         </member>
         <member name="T:LightweightIocContainer.Exceptions.MultipleRegistrationException">
             <summary>
-            The <see cref="T:System.Type"/> is already registered in this <see cref="T:LightweightIocContainer.Interfaces.IIocContainer"/>
+            The <see cref="T:System.Type"/> is already registered differently in this <see cref="T:LightweightIocContainer.Interfaces.IIocContainer"/>
             </summary>
         </member>
         <member name="M:LightweightIocContainer.Exceptions.MultipleRegistrationException.#ctor(System.Type)">
             <summary>
-            The <see cref="T:System.Type"/> is already registered in this <see cref="T:LightweightIocContainer.Interfaces.IIocContainer"/>
+            The <see cref="T:System.Type"/> is already registered differently in this <see cref="T:LightweightIocContainer.Interfaces.IIocContainer"/>
             </summary>
             <param name="type">The <see cref="T:System.Type"/> that is already registered in this <see cref="T:LightweightIocContainer.Interfaces.IIocContainer"/></param>
         </member>

LightweightIocContainer/Registrations/MultipleRegistration.cs

@@ -30,7 +30,7 @@ namespace LightweightIocContainer.Registrations
         /// <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 set; }
+        public List<IRegistration> Registrations { get; protected init; }
     }
 
     /// <summary>

LightweightIocContainer/Registrations/MultitonRegistration.cs

@@ -49,5 +49,11 @@ namespace LightweightIocContainer.Registrations
             
             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);
     }
 }

LightweightIocContainer/Registrations/OpenGenericRegistration.cs

@@ -43,5 +43,11 @@ namespace LightweightIocContainer.Registrations
             
             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);
     }
 }

LightweightIocContainer/Registrations/RegistrationBase.cs

@@ -213,5 +213,35 @@ namespace LightweightIocContainer.Registrations
                 }
             }
         }
+
+        public override bool Equals(object? obj)
+        {
+            if (obj is not RegistrationBase registrationBase)
+                return false;
+
+            if (Parameters == null && registrationBase.Parameters != null)
+                return false;
+
+            if (Parameters != null && registrationBase.Parameters == null)
+                return false;
+
+            if (Parameters?.Length != registrationBase.Parameters?.Length)
+                return false;
+            
+            if (Factory == null && registrationBase.Factory != null)
+                return false;
+
+            if (Factory != null && registrationBase.Factory == null)
+                return false;
+
+            if (Factory?.CreateMethods.Count != registrationBase.Factory?.CreateMethods.Count)
+                return false;
+            
+            return InterfaceType == registrationBase.InterfaceType &&
+                   Lifestyle == registrationBase.Lifestyle &&
+                   DisposeStrategy == registrationBase.DisposeStrategy;
+        }
+        
+        public override int GetHashCode() => HashCode.Combine(InterfaceType, (int) Lifestyle);
     }
 }

LightweightIocContainer/Registrations/SingleTypeRegistration.cs

@@ -41,5 +41,21 @@ namespace LightweightIocContainer.Registrations
             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

@@ -12,7 +12,7 @@ namespace LightweightIocContainer.Registrations
     /// 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>
-    public class TypedFactoryRegistration<TFactory> : ITypedFactoryRegistration<TFactory>
+    internal class TypedFactoryRegistration<TFactory> : ITypedFactoryRegistration<TFactory>
     {
         /// <summary>
         /// The registration that is used to register an abstract typed factory
@@ -29,5 +29,11 @@ namespace LightweightIocContainer.Registrations
         /// The class that contains the implemented abstract factory of this <see cref="TypedFactoryRegistration{TFactory}"/>
         /// </summary>
         public ITypedFactory<TFactory> Factory { get; }
+
+        public override bool Equals(object? obj) => obj is TypedFactoryRegistration<TFactory> factoryRegistration && 
+                                                    Factory.CreateMethods.Count == factoryRegistration.Factory.CreateMethods.Count &&
+                                                    InterfaceType == factoryRegistration.InterfaceType;
+
+        public override int GetHashCode() => HashCode.Combine(InterfaceType);
     }
 }

LightweightIocContainer/Registrations/TypedRegistration.cs

@@ -58,5 +58,24 @@ namespace LightweightIocContainer.Registrations
         /// Validate the <see cref="DisposeStrategy"/> for the <see cref="ImplementationType"/> and <see cref="Lifestyle"/>
         /// </summary>
         protected override void ValidateDisposeStrategy() => ValidateDisposeStrategy(ImplementationType);
+
+        public override bool Equals(object? obj)
+        {
+            if (obj is not TypedRegistration<TInterface, TImplementation> typedRegistration)
+                return false;
+
+            if (!base.Equals(obj))
+                return false;
+
+            if (OnCreateAction == null && typedRegistration.OnCreateAction != null)
+                return false;
+
+            if (OnCreateAction != null && typedRegistration.OnCreateAction == null)
+                return false;
+            
+            return ImplementationType == typedRegistration.ImplementationType;
+        }
+
+        public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), ImplementationType);
     }
 }

Test.LightweightIocContainer/IocContainerTest.cs

@@ -146,13 +146,27 @@ namespace Test.LightweightIocContainer
         public void TestInvalidMultitonRegistration() => Assert.Throws<InvalidRegistrationException>(() => _iocContainer.Register(r => r.Add<ITest, Test>(Lifestyle.Multiton)));
 
         [Test]
-        public void TestRegisterMultiple()
+        public void TestRegisterMultipleDifferent()
         {
             _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]
+        public void TestRegisterMultipleSame()
+        {
+            _iocContainer.Register(r => r.Add<ITest, Test>());
+            Assert.DoesNotThrow(() => _iocContainer.Register(r => r.Add<ITest, Test>()));
+        }
+
+        [Test]
+        public void TestRegisterMultipleSameWithParameters()
+        {
+            _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())));
+        }
+        
         [Test]
         public void TestResolveNotRegistered()
         {