Refactor ForeignKeys.IsTransient to reduce Async method generations

Author: hazzik

src/NHibernate.sln.DotSettings

@@ -14,6 +14,7 @@
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARGUMENTS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARRAY_INITIALIZER_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_BEFORE_FIRST_TYPE_PARAMETER_CONSTRAINT/@EntryValue">True</s:Boolean>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_LIMIT/@EntryValue">400</s:Int64>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_PARAMETERS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CSharpUsing/AddImportsToDeepestScope/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateConstants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>

src/NHibernate/Engine/ForeignKeys.cs

@@ -164,6 +164,19 @@ public static bool IsNotTransient(string entityName, System.Object entity, bool?
 			return !IsTransient(entityName, entity, assumed, session);
 		}
 
+
+		/// <summary> 
+		/// Is this instance persistent or detached?
+		/// </summary>
+		internal static bool? IsNotTransient(string entityName, object entity, ISessionImplementor session)
+		{
+			if (entity.IsProxy())
+				return true;
+			if (session.PersistenceContext.IsEntryFor(entity))
+				return true;
+			return !IsTransient(entityName, entity, session);
+		}
+
 		/// <summary> 
 		/// Is this instance, which we know is not persistent, actually transient? 
 		/// If <tt>assumed</tt> is non-null, don't hit the database to make the 
@@ -176,6 +189,24 @@ public static bool IsNotTransient(string entityName, System.Object entity, bool?
 		/// prepared to "recover" in the case that this assumed result is incorrect.
 		/// </remarks>
 		public static bool IsTransient(string entityName, object entity, bool? assumed, ISessionImplementor session)
+		{
+			var isUnsaved = IsTransient(entityName, entity, session);
+			if (isUnsaved.HasValue)
+				return isUnsaved.Value;
+			if (assumed.HasValue)
+				// we use the assumed value, if there is one, to avoid hitting
+				// the database
+				return assumed.Value;
+			return IsPersisted(entityName, entity, session);
+		}
+
+		/// <summary> 
+		/// Is this instance, which we know is not persistent, actually transient? 
+		/// If <tt>assumed</tt> is non-null, don't hit the database to make the 
+		/// determination, instead assume that value; the client code must be 
+		/// prepared to "recover" in the case that this assumed result is incorrect.
+		/// </summary>
+		public static bool? IsTransient(string entityName, object entity, ISessionImplementor session)
 		{
 			if (Equals(Intercept.LazyPropertyInitializer.UnfetchedProperty, entity))
 			{
@@ -190,16 +221,13 @@ public static bool IsTransient(string entityName, object entity, bool? assumed,
 				return isUnsaved.Value;
 
 			// let the persister inspect the instance to decide
-			IEntityPersister persister = session.GetEntityPersister(entityName, entity);
-			isUnsaved = persister.IsTransient(entity, session);
-			if (isUnsaved.HasValue)
-				return isUnsaved.Value;
-
-			// we use the assumed value, if there is one, to avoid hitting
-			// the database
-			if (assumed.HasValue)
-				return assumed.Value;
+			var persister = session.GetEntityPersister(entityName, entity);
+			return persister.IsTransient(entity, session);
+		}
 
+		public static bool IsPersisted(string entityName, object entity, ISessionImplementor session)
+		{
+			var persister = session.GetEntityPersister(entityName, entity);
 			if (persister.IdentifierGenerator is Assigned)
 			{
 				// When using assigned identifiers we cannot tell if an entity
@@ -247,7 +275,7 @@ public static object GetEntityIdentifierIfNotUnsaved(string entityName, object e
 						return entity;
 					/**********************************************/
 
-					if (IsTransient(entityName, entity, false, session))
+					if (IsTransient(entityName, entity, session) ?? false)
 					{
 						/***********************************************/
 						// TODO NH verify the behavior of NH607 test

src/NHibernate/Event/Default/DefaultLockEventListener.cs

@@ -42,7 +42,7 @@ public virtual void OnLock(LockEvent @event)
 			{
 				IEntityPersister persister = source.GetEntityPersister(@event.EntityName, entity);
 				object id = persister.GetIdentifier(entity);
-				if (!ForeignKeys.IsNotTransient(@event.EntityName, entity, false, source))
+				if (ForeignKeys.IsNotTransient(@event.EntityName, entity, source) == true)
 				{
 					throw new TransientObjectException("cannot lock an unsaved transient instance: " + persister.EntityName);
 				}

src/NHibernate/Event/Default/DefaultRefreshEventListener.cs

@@ -118,7 +118,7 @@ public virtual void OnRefresh(RefreshEvent @event, IDictionary refreshedAlready)
 
 			// NH Different behavior : we are ignoring transient entities without throw any kind of exception
 			// because a transient entity is "self refreshed"
-			if (!ForeignKeys.IsTransient(persister.EntityName, obj, result == null, @event.Session))
+			if (!(ForeignKeys.IsTransient(persister.EntityName, obj, @event.Session) ?? (result == null)))
 				UnresolvableObjectException.ThrowIfNull(result, id, persister.EntityName);
 		}
 

src/NHibernate/Type/EntityType.cs

@@ -239,7 +239,7 @@ public override object Replace(object original, object target, ISessionImplement
 				{
 					return target;
 				}
-				if (session.GetContextEntityIdentifier(original) == null && ForeignKeys.IsTransient(associatedEntityName, original, false, session))
+				if (session.GetContextEntityIdentifier(original) == null && (ForeignKeys.IsTransient(associatedEntityName, original, session) ?? false))
 				{
 					object copy = session.Factory.GetEntityPersister(associatedEntityName).Instantiate(null);
 					//TODO: should this be Session.instantiate(Persister, ...)?