NH-2931 - Process classes accordingly to inheritance path in mapping by code

Author: hazzik

src/NHibernate.Test/NHSpecificTest/NH2931/Fixture.cs

@@ -0,0 +1,40 @@
+using NHibernate.Mapping.ByCode;
+using NUnit.Framework;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace NHibernate.Test.NHSpecificTest.NH2931
+{
+    [TestFixture]
+    public class MappingByCodeTest : BugTestCase
+    {
+        //no xml mappings here, since we use MappingByCode
+        protected override System.Collections.IList Mappings
+        {
+            get { return new string[0]; }
+        }
+
+        [Test]
+        public void CompiledMappings_ShouldNotDependOnAddedOrdering_AddedBy_AddMapping()
+        {
+            var mapper = new ModelMapper();
+            mapper.AddMapping<EntityMapping>();
+            mapper.AddMapping<DerivedClassMapping>();
+            mapper.AddMapping<BaseClassMapping>();
+            var config = TestConfigurationHelper.GetDefaultConfiguration();
+            Assert.DoesNotThrow(() => config.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities()));
+        }
+
+        [Test]
+        public void CompiledMappings_ShouldNotDependOnAddedOrdering_AddedBy_AddMappings()
+        {
+            var mapper = new ModelMapper();
+            mapper.AddMappings(typeof(EntityMapping).Assembly
+                .GetExportedTypes()
+                //only add our test entities/mappings
+                .Where(t => t.Namespace == typeof(MappingByCodeTest).Namespace));
+            var config = TestConfigurationHelper.GetDefaultConfiguration();
+            Assert.DoesNotThrow(() => config.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities()));
+        }
+    }
+}

src/NHibernate.Test/NHSpecificTest/NH2931/Mappings.cs

@@ -0,0 +1,37 @@
+using NHibernate.Mapping.ByCode;
+using NHibernate.Mapping.ByCode.Conformist;
+
+namespace NHibernate.Test.NHSpecificTest.NH2931
+{
+    public class EntityMapping : ClassMapping<Entity>
+    {
+        public EntityMapping()
+        {
+            Id(i => i.Id, m => m.Generator(Generators.GuidComb));
+        }
+    }
+    //NOTE: tests may work if the order of mappings is
+    // 1) BaseClassMapping
+    // 2) DerivedClassMapping
+    //but they always fail when
+    // 1) DerivedClassMapping
+    // 2) BaseClassMapping
+    //MappingByCodeTest.CompiledMappings_ShouldNotDependOnAddedOrdering_AddedBy_AddMapping
+    // explicitly forces the first ordering to occur, but the most common use is simply
+    // typeof(SomeEntity).Assembly.GetTypes() to register everything; as shown in 
+    //MappingByCodeTest.CompiledMappings_ShouldNotDependOnAddedOrdering_AddedBy_AddMappings
+    public class DerivedClassMapping : JoinedSubclassMapping<DerivedClass>
+    {
+        public DerivedClassMapping()
+        {
+            Property(p => p.DerivedProperty);
+        }
+    }
+    public class BaseClassMapping : JoinedSubclassMapping<BaseClass>
+    {
+        public BaseClassMapping()
+        {
+            Property(p => p.BaseProperty);
+        }
+    }
+}

src/NHibernate.Test/NHSpecificTest/NH2931/Models.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace NHibernate.Test.NHSpecificTest.NH2931
+{
+    public abstract class Entity
+    {
+        public Guid Id { get; private set; }
+    }
+    public class BaseClass : Entity
+    {
+        public string BaseProperty { get; set; }
+    }
+    public class DerivedClass : BaseClass
+    {
+        public string DerivedProperty { get; set; }
+    }
+}

src/NHibernate.Test/NHibernate.Test.csproj

@@ -718,6 +718,9 @@
     <Compile Include="NHSpecificTest\BagWithLazyExtraAndFilter\Fixture.cs" />
     <Compile Include="Linq\ByMethod\DistinctTests.cs" />
     <Compile Include="Component\Basic\ComponentWithUniqueConstraintTests.cs" />
+    <Compile Include="NHSpecificTest\NH2931\Fixture.cs" />
+    <Compile Include="NHSpecificTest\NH2931\Mappings.cs" />
+    <Compile Include="NHSpecificTest\NH2931\Models.cs" />
     <Compile Include="NHSpecificTest\NH3518\ClassWithXmlMember.cs" />
     <Compile Include="NHSpecificTest\NH3518\XmlColumnTest.cs" />
     <Compile Include="NHSpecificTest\NH3609\MappingEntity.cs" />

src/NHibernate/Mapping/ByCode/ModelMapper.cs

@@ -548,7 +548,10 @@ public HbmMapping CompileMappingFor(IEnumerable<System.Type> types)
 			{
 				throw new ArgumentNullException("types");
 			}
-			var typeToMap = new HashSet<System.Type>(types);
+
+			var typeToMap = types.Distinct()
+								 .OrderBy(x => x, new TypeHierarchyComparer())
+								 .ToList();
 
 			string defaultAssemblyName = null;
 			string defaultNamespace = null;
@@ -563,11 +566,11 @@ public HbmMapping CompileMappingFor(IEnumerable<System.Type> types)
 				defaultNamespace = firstType.Namespace;
 			}
 			var mapping = NewHbmMapping(defaultAssemblyName, defaultNamespace);
-			foreach (System.Type type in RootClasses(typeToMap))
+			foreach (var type in RootClasses(typeToMap))
 			{
 				MapRootClass(type, mapping);
 			}
-			foreach (System.Type type in Subclasses(typeToMap))
+			foreach (var type in Subclasses(typeToMap))
 			{
 				AddSubclassMapping(mapping, type);
 			}
@@ -580,16 +583,18 @@ public IEnumerable<HbmMapping> CompileMappingForEach(IEnumerable<System.Type> ty
 			{
 				throw new ArgumentNullException("types");
 			}
-			var typeToMap = new HashSet<System.Type>(types);
+			var typeToMap = types.Distinct()
+								 .OrderBy(x => x, new TypeHierarchyComparer())
+								 .ToList();
 
 			//NH-2831: always use the full name of the assembly because it may come from GAC
-			foreach (System.Type type in RootClasses(typeToMap))
+			foreach (var type in RootClasses(typeToMap))
 			{
 				var mapping = NewHbmMapping(type.Assembly.GetName().FullName, type.Namespace);
 				MapRootClass(type, mapping);
 				yield return mapping;
 			}
-			foreach (System.Type type in Subclasses(typeToMap))
+			foreach (var type in Subclasses(typeToMap))
 			{
 				var mapping = NewHbmMapping(type.Assembly.GetName().FullName, type.Namespace);
 				AddSubclassMapping(mapping, type);
@@ -1815,5 +1820,16 @@ public IEnumerable<HbmMapping> CompileMappingForEachExplicitlyAddedEntity()
 		{
 			return CompileMappingForEach(customizerHolder.GetAllCustomizedEntities());
 		}
+
+		private class TypeHierarchyComparer : IComparer<System.Type>
+		{
+			public int Compare(System.Type x, System.Type y)
+			{
+				if (x == y) return 0;
+				if (x.IsAssignableFrom(y)) return -1;
+				if (y.IsAssignableFrom(x)) return 1;
+				return 0;
+			}
+		}
 	}
-}
+}