Avoid some cases of Type -> AssemblyQualifiedTypeName-> Type conversion in MappingByCode

Author: bahusoid

src/NHibernate/Mapping/ByCode/Impl/TypeNameUtil.cs

@@ -8,7 +8,7 @@ public static class TypeNameUtil
 		public static string GetNhTypeName(this System.Type type)
 		{
 			string typeName;
-			IType nhType = TypeFactory.HeuristicType(type.AssemblyQualifiedName);
+			IType nhType = TypeFactory.HeuristicType(type);
 			if (nhType != null)
 			{
 				typeName = nhType.Name;
@@ -68,4 +68,4 @@ private static string GetTypeNameForMapping(System.Type type)
 			return type.Name;
 		}
 	}
-}
+}

src/NHibernate/Type/TypeFactory.cs

@@ -522,6 +522,22 @@ public static IType HeuristicType(string typeName)
 			return HeuristicType(typeName, null);
 		}
 
+		/// <summary>
+		/// Uses heuristics to deduce a NHibernate type given a string naming the
+		/// type.
+		/// </summary>
+		/// <param name="type"></param>
+		/// <returns>An instance of <c>NHibernate.Type.IType</c></returns>
+		/// <remarks>
+		/// We check to see if it implements IType, ICompositeUserType, IUserType, ILifecycle (Association), or
+		/// IPersistentEnum.  If none of those are implemented then we will serialize the Type to the
+		/// database using NHibernate.Type.SerializableType(typeName)
+		/// </remarks>
+		public static IType HeuristicType(System.Type type)
+		{
+			return HeuristicType(type, typeName: null, parameters: null, length: null);
+		}
+
 		/// <summary>
 		/// Uses heuristics to deduce a NHibernate type given a string naming the type.
 		/// </summary>
@@ -532,7 +548,7 @@ public static IType HeuristicType(string typeName, IDictionary<string, string> p
 		{
 			return HeuristicType(typeName, parameters, null);
 		}
-		
+
 		/// <summary>
 		/// Uses heuristics to deduce a NHibernate type given a string naming the type.
 		/// </summary>
@@ -542,50 +558,63 @@ public static IType HeuristicType(string typeName, IDictionary<string, string> p
 		/// <returns></returns>
 		public static IType HeuristicType(string typeName, IDictionary<string, string> parameters, int? length)
 		{
-			IType type = Basic(typeName, parameters);
+			return HeuristicType(/*resolvedType:*/ null, typeName, parameters, length);
+		}
 
-			if (type != null)
-				return type;
-			
-			string[] parsedTypeName;
-			TypeClassification typeClassification = GetTypeClassification(typeName);
-			if (typeClassification == TypeClassification.LengthOrScale)
-				parsedTypeName = typeName.Split(LengthSplit);
-			else
-				parsedTypeName = typeClassification == TypeClassification.PrecisionScale ? typeName.Split(PrecisionScaleSplit) : new[] { typeName };
+		/// <summary>
+		/// Provide either resolvedType or typeName. resolvedType takes precedence.
+		/// </summary>
+		private static IType HeuristicType(System.Type resolvedType, string typeName, IDictionary<string, string> parameters, int? length)
+		{
+			if (resolvedType == null)
+			{
+				IType type = Basic(typeName, parameters);
 
+				if (type != null)
+					return type;
 
-			System.Type typeClass;
-			try
-			{
-				typeClass = ReflectHelper.ClassForName(parsedTypeName[0]); //typeName);
-			}
-			catch (Exception)
-			{
-				typeClass = null;
-			}
+				string[] parsedTypeName;
+				var typeClassification = GetTypeClassification(typeName);
+				if (typeClassification == TypeClassification.LengthOrScale)
+				{
+					parsedTypeName = typeName.Split(LengthSplit);
+					if(!int.TryParse(parsedTypeName[1], out int parsedLength))
+					{
+						throw new MappingException($"Could not parse length value '{parsedTypeName[1]}' as int for type '{typeName}'");
+					}
+					length = parsedLength;
+				}
+				else
+					parsedTypeName = typeClassification == TypeClassification.PrecisionScale ? typeName.Split(PrecisionScaleSplit) : new[] { typeName };
 
-			if (typeClass == null)
-				return null;
-				
+				try
+				{
+					resolvedType = ReflectHelper.ClassForName(parsedTypeName[0]); //typeName);
+				}
+				catch (Exception)
+				{
+					return null;
+				}
+			}
+			var typeClass = resolvedType;
 			if (typeof(IType).IsAssignableFrom(typeClass))
 			{
 				try
 				{
-					type = (IType) Environment.ObjectsFactory.CreateInstance(typeClass);
+					var type = (IType) Environment.ObjectsFactory.CreateInstance(typeClass);
+					InjectParameters(type, parameters);
+
+					var obsolete = typeClass.GetCustomAttribute<ObsoleteAttribute>(false);
+					if (obsolete != null)
+					{
+						_log.Warn("{0} is obsolete. {1}", typeName, obsolete.Message);
+					}
+					return type;
 				}
 				catch (Exception e)
 				{
 					throw new MappingException("Could not instantiate IType " + typeClass.Name + ": " + e, e);
 				}
-				InjectParameters(type, parameters);
-
-				var obsolete = typeClass.GetCustomAttribute<ObsoleteAttribute>(false);
-				if (obsolete != null)
-				{
-					_log.Warn("{0} is obsolete. {1}", typeName, obsolete.Message);
-				}
-				return type;
 			}
 			if (typeof(ICompositeUserType).IsAssignableFrom(typeClass))
 			{
@@ -609,9 +638,6 @@ public static IType HeuristicType(string typeName, IDictionary<string, string> p
 			if (!typeClass.IsSerializable)
 				return null;
 
-			if (typeClassification == TypeClassification.LengthOrScale)
-				return GetSerializableType(typeClass, Int32.Parse(parsedTypeName[1]));
-			
 			if (length.HasValue)
 				return GetSerializableType(typeClass, length.Value);