Tiny cleanup refactoring of AutoPersistenceModel

Author: jagregory

src/FluentNHibernate/Automapping/AutoMapper.cs

@@ -5,6 +5,7 @@
 using FluentNHibernate.MappingModel;
 using FluentNHibernate.MappingModel.ClassBased;
 using FluentNHibernate.Utils;
+using FluentNHibernate.Utils.Reflection;
 
 namespace FluentNHibernate.Automapping
 {
@@ -24,7 +25,7 @@ public AutoMapper(IAutomappingConfiguration cfg, IConventionFinder conventionFin
 
         private void ApplyOverrides(Type classType, IList<Member> mappedMembers, ClassMappingBase mapping)
         {
-            var autoMapType = typeof(AutoMapping<>).MakeGenericType(classType);
+            var autoMapType = ReflectionHelper.AutomappingTypeForEntityType(classType);
             var autoMap = Activator.CreateInstance(autoMapType, mappedMembers);
 
             inlineOverrides

src/FluentNHibernate/Automapping/AutoPersistenceModel.cs

@@ -8,6 +8,8 @@
 using FluentNHibernate.Mapping.Providers;
 using FluentNHibernate.MappingModel;
 using FluentNHibernate.MappingModel.ClassBased;
+using FluentNHibernate.Utils;
+using FluentNHibernate.Utils.Reflection;
 using FluentNHibernate.Visitors;
 
 namespace FluentNHibernate.Automapping
@@ -345,37 +347,40 @@ public AutoPersistenceModel Override<T>(Action<AutoMapping<T>> populateMap)
             return this;
         }
 
+        static bool IsAutomappingForType(object o, Type entityType)
+        {
+            var autoMappingType = ReflectionHelper.AutomappingTypeForEntityType(entityType);
+
+            return o.GetType().IsAssignableFrom(autoMappingType);
+        }
+
 		/// <summary>
 		/// Adds an IAutoMappingOverride reflectively
 		/// </summary>
 		/// <param name="overrideType">Override type, expected to be an IAutoMappingOverride</param>
 		public void Override(Type overrideType)
 		{
-			Type overrideInterface = overrideType.GetInterfaces()
-				.Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IAutoMappingOverride<>) && x.GetGenericArguments().Length > 0)
-				.FirstOrDefault();
-			if (overrideInterface != null)
-			{
-				Type entityType = overrideInterface.GetGenericArguments().First();
-				Type autoMappingType = typeof(AutoMapping<>).MakeGenericType(entityType);
-				AddOverride(entityType, x =>
-				{
-					if (x.GetType().IsAssignableFrom(autoMappingType))
-					{
-						var overrideInstance = Activator.CreateInstance(overrideType);
-
-						MethodInfo overrideHelperMethod = typeof(AutoPersistenceModel)
-							.GetMethod("OverrideHelper", BindingFlags.NonPublic | BindingFlags.Instance);
-						
-						if (overrideHelperMethod != null)
-						{
-							overrideHelperMethod
-								.MakeGenericMethod(entityType)
-								.Invoke(this, new[] {x, overrideInstance});
-						}
-					}
-				});
-			}
+			var overrideInterface = overrideType.GetInterfaces().FirstOrDefault(x => x.IsAutoMappingOverrideType());
+
+		    if (overrideInterface == null) return;
+		    
+            var entityType = overrideInterface.GetGenericArguments().First();
+
+		    AddOverride(entityType, instance =>
+		    {
+		        if (!IsAutomappingForType(instance, entityType)) return;
+
+		        var overrideInstance = Activator.CreateInstance(overrideType);
+
+		        MethodInfo overrideHelperMethod = typeof(AutoPersistenceModel)
+		            .GetMethod("OverrideHelper", BindingFlags.NonPublic | BindingFlags.Instance);
+
+		        if (overrideHelperMethod == null) return;
+
+		        overrideHelperMethod
+		            .MakeGenericMethod(entityType)
+		            .Invoke(this, new[] {instance, overrideInstance});
+		    });
 		}
 
 		//called reflectively from method above

src/FluentNHibernate/Utils/Extensions.cs

@@ -2,6 +2,7 @@
 using System.IO;
 using System.Linq;
 using System.Runtime.Serialization.Formatters.Binary;
+using FluentNHibernate.Automapping.Alterations;
 using NHibernate.Util;
 
 namespace FluentNHibernate.Utils
@@ -75,5 +76,10 @@ public static T DeepClone<T>(this T obj)
                 return (T)formatter.Deserialize(stream);
             }
         }
+
+        public static bool IsAutoMappingOverrideType(this Type type)
+        {
+            return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IAutoMappingOverride<>) && type.GetGenericArguments().Length > 0;
+        }
     }
 }

src/FluentNHibernate/Utils/Reflection/ReflectionHelper.cs

@@ -4,11 +4,17 @@
 using System.Reflection;
 
 using FluentNHibernate;
+using FluentNHibernate.Automapping;
 
 namespace FluentNHibernate.Utils.Reflection
 {
     public static class ReflectionHelper
     {
+        public static Type AutomappingTypeForEntityType(Type entityType)
+        {
+            return typeof(AutoMapping<>).MakeGenericType(entityType);
+        }
+
         public static Member GetMember<TModel, TReturn>(Expression<Func<TModel, TReturn>> expression)
         {
             return GetMember(expression.Body);