Use reference equality in InsertActionSorter

Author: bahusoid

src/NHibernate.Test/Async/Insertordering/AnimalModel/Fixture.cs

@@ -163,5 +163,29 @@ public async System.Threading.Tasks.Task InsertShouldNotInitializeOneToManyProxy
 				// instead.)
 			}
 		}
+
+		// #2141
+		[Test]
+		public async System.Threading.Tasks.Task InsertShouldNotDependOnEntityEqualsImplementationAsync()
+		{
+			var person = new PersonWithWrongEquals { Name = "AnimalOwner" };
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				await (s.SaveAsync(person));
+				await (t.CommitAsync());
+			}
+			await (Sfi.EvictAsync(typeof(PersonWithWrongEquals)));
+
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				var personProxy = await (s.GetAsync<PersonWithWrongEquals>(person.Id));
+
+				await (s.SaveAsync(new Cat { Name = "Felix", Owner = personProxy }));
+				await (s.SaveAsync(new Cat { Name = "Loustic", Owner = personProxy }));
+				Assert.DoesNotThrowAsync(() => { return t.CommitAsync(); });
+			}
+		}
 	}
 }

src/NHibernate.Test/Insertordering/AnimalModel/Fixture.cs

@@ -153,5 +153,29 @@ public void InsertShouldNotInitializeOneToManyProxy()
 				// instead.)
 			}
 		}
+
+		// #2141
+		[Test]
+		public void InsertShouldNotDependOnEntityEqualsImplementation()
+		{
+			var person = new PersonWithWrongEquals { Name = "AnimalOwner" };
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				s.Save(person);
+				t.Commit();
+			}
+			Sfi.Evict(typeof(PersonWithWrongEquals));
+
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				var personProxy = s.Get<PersonWithWrongEquals>(person.Id);
+
+				s.Save(new Cat { Name = "Felix", Owner = personProxy });
+				s.Save(new Cat { Name = "Loustic", Owner = personProxy });
+				Assert.DoesNotThrow(() => { t.Commit(); });
+			}
+		}
 	}
 }

src/NHibernate.Test/Insertordering/AnimalModel/Mappings.hbm.xml

@@ -61,5 +61,11 @@
         <one-to-many class="SivasKangal"/>
       </bag>
     </subclass>
+    <subclass name="PersonWithWrongEquals" discriminator-value="6">
+      <bag name="SivasKangalsGeneric" lazy="true" inverse="true" cascade="save-update">
+        <key column="OwnerId" />
+        <one-to-many class="SivasKangal"/>
+      </bag>
+    </subclass>
   </class>
-</hibernate-mapping>
+</hibernate-mapping>

src/NHibernate.Test/Insertordering/AnimalModel/PersonWithSivasKangals.cs

@@ -1,9 +1,24 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace NHibernate.Test.Insertordering.AnimalModel
 {
 	public class PersonWithSivasKangals : Person
 	{
 		public virtual IList<SivasKangal> SivasKangalsGeneric { get; set; } = new List<SivasKangal>();
 	}
+
+	public class PersonWithWrongEquals : Person
+	{
+		public override bool Equals(object obj)
+		{
+			throw new ApplicationException("Equals call is unexpected.");
+		}
+		public override int GetHashCode()
+		{
+			throw new ApplicationException("GetHashCode call is unexpected.");
+		}
+
+		public virtual IList<SivasKangal> SivasKangalsGeneric { get; set; } = new List<SivasKangal>();
+	}
 }

src/NHibernate/Async/Engine/ActionQueue.cs

@@ -18,6 +18,7 @@
 using NHibernate.Action;
 using NHibernate.Cache;
 using NHibernate.Type;
+using NHibernate.Util;
 
 namespace NHibernate.Engine
 {

src/NHibernate/Engine/ActionQueue.cs

@@ -8,6 +8,7 @@
 using NHibernate.Action;
 using NHibernate.Cache;
 using NHibernate.Type;
+using NHibernate.Util;
 
 namespace NHibernate.Engine
 {
@@ -605,7 +606,7 @@ private class InsertActionSorter
 			// The map of entities to their batch.
 			private readonly Dictionary<object, int> _entityBatchNumber;
 			// The map of entities to the latest batch (of another entities) they depend on.
-			private readonly Dictionary<object, int> _entityBatchDependency = new Dictionary<object, int>();
+			private readonly Dictionary<object, int> _entityBatchDependency = new Dictionary<object, int>(ReferenceComparer<object>.Instance);
 
 			// the map of batch numbers to EntityInsertAction lists
 			private readonly Dictionary<int, List<AbstractEntityInsertAction>> _actionBatches = new Dictionary<int, List<AbstractEntityInsertAction>>();
@@ -619,7 +620,7 @@ public InsertActionSorter(ActionQueue actionQueue)
 				_actionQueue = actionQueue;
 
 				//optimize the hash size to eliminate a rehash.
-				_entityBatchNumber = new Dictionary<object, int>(actionQueue.insertions.Count + 1);
+				_entityBatchNumber = new Dictionary<object, int>(actionQueue.insertions.Count + 1, ReferenceComparer<object>.Instance);
 			}
 
 			// This sorting does not actually optimize some features like mapped inheritance or joined-table,

src/NHibernate/Util/ReferenceComparer.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace NHibernate.Util
+{
+	/// <summary>
+	/// Compares objects by reference equality
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	[Serializable]
+	class ReferenceComparer<T> : IEqualityComparer, IEqualityComparer<T> where T : class
+	{
+		private ReferenceComparer()
+		{
+		}
+
+		public bool Equals(T x, T y)
+		{
+			return ReferenceEquals(x, y);
+		}
+
+		public int GetHashCode(T obj)
+		{
+			return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+		}
+
+		bool IEqualityComparer.Equals(object x, object y)
+		{
+			return ReferenceEquals(x, y);
+		}
+
+		int IEqualityComparer.GetHashCode(object obj)
+		{
+			return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
+		}
+
+		public static readonly ReferenceComparer<T> Instance = new ReferenceComparer<T>();
+	}
+}