Regenerate async: call forwarding

Author: hazzik

src/NHibernate/Async/Action/BulkOperationCleanupAction.cs

@@ -27,7 +27,15 @@ public partial class BulkOperationCleanupAction: IExecutable
 
 		public Task ExecuteAsync()
 		{
-			return Task.CompletedTask;
+			try
+			{
+				Execute();
+				return Task.CompletedTask;
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
 			// nothing to do
 		}
 

src/NHibernate/Async/Action/EntityAction.cs

@@ -31,7 +31,15 @@ public abstract partial class EntityAction : IExecutable, IComparable<EntityActi
 
 		protected virtual Task AfterTransactionCompletionProcessImplAsync(bool success)
 		{
-			return Task.CompletedTask;
+			try
+			{
+				AfterTransactionCompletionProcessImpl(success);
+				return Task.CompletedTask;
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
 		}
 
 		#endregion

src/NHibernate/Async/AdoNet/NonBatchingBatcher.cs

@@ -50,7 +50,15 @@ public override async Task AddToBatchAsync(IExpectation expectation)
 		/// <param name="ps"></param>
 		protected override Task DoExecuteBatchAsync(DbCommand ps)
 		{
-			return Task.CompletedTask;
+			try
+			{
+				DoExecuteBatch(ps);
+				return Task.CompletedTask;
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
 		}
 	}
 }

src/NHibernate/Async/Collection/AbstractPersistentCollection.cs

@@ -134,7 +134,15 @@ public Task<ICollection> GetQueuedOrphansAsync(string entityName)
 		/// Called before inserting rows, to ensure that any surrogate keys are fully generated
 		/// </summary>
 		/// <param name="persister"></param>
-		public virtual Task PreInsertAsync(ICollectionPersister persister) {			return Task.CompletedTask;
+		public virtual Task PreInsertAsync(ICollectionPersister persister) {			try
+			{
+				PreInsert(persister);
+				return Task.CompletedTask;
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
 }
 
 		/// <summary>

src/NHibernate/Async/Engine/CascadingAction.cs

@@ -47,7 +47,15 @@ public abstract partial class CascadingAction
 		/// <param name="propertyIndex">The index of the property within the owner. </param>
 		public virtual Task NoCascadeAsync(IEventSource session, object child, object parent, IEntityPersister persister, int propertyIndex)
 		{
-			return Task.CompletedTask;
+			try
+			{
+				NoCascade(session, child, parent, persister, propertyIndex);
+				return Task.CompletedTask;
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
 		}
 
 		#endregion

src/NHibernate/Async/Event/Default/AbstractVisitor.cs

@@ -96,7 +96,7 @@ internal virtual Task<object> ProcessCollectionAsync(object value, CollectionTyp
 		{
 			try
 			{
-				return Task.FromResult<object>(null);
+				return Task.FromResult<object>(ProcessCollection(value, collectionType));
 			}
 			catch (Exception ex)
 			{

src/NHibernate/Async/Event/Default/DefaultMergeEventListener.cs

@@ -531,13 +531,29 @@ protected async Task RetryMergeTransientEntitiesAsync(MergeEvent @event, IDictio
 		/// <summary> Cascade behavior is redefined by this subclass, disable superclass behavior</summary>
 		protected override Task CascadeAfterSaveAsync(IEventSource source, IEntityPersister persister, object entity, object anything)
 		{
-			return Task.CompletedTask;
+			try
+			{
+				CascadeAfterSave(source, persister, entity, anything);
+				return Task.CompletedTask;
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
 		}
 
 		/// <summary> Cascade behavior is redefined by this subclass, disable superclass behavior</summary>
 		protected override Task CascadeBeforeSaveAsync(IEventSource source, IEntityPersister persister, object entity, object anything)
 		{
-			return Task.CompletedTask;
+			try
+			{
+				CascadeBeforeSave(source, persister, entity, anything);
+				return Task.CompletedTask;
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
 		}
 	}
 }

src/NHibernate/Async/Event/Default/DefaultPreLoadEventListener.cs

@@ -23,8 +23,7 @@ public virtual Task OnPreLoadAsync(PreLoadEvent @event)
 		{
 			try
 			{
-				IEntityPersister persister = @event.Persister;
-				@event.Session.Interceptor.OnLoad(@event.Entity, @event.Id, @event.State, persister.PropertyNames, persister.PropertyTypes);
+				OnPreLoad(@event);
 				return Task.CompletedTask;
 			}
 			catch (Exception ex)

src/NHibernate/Async/Event/Default/DefaultReplicateEventListener.cs

@@ -150,7 +150,7 @@ protected override Task<bool> SubstituteValuesIfNecessaryAsync(object entity, ob
 		{
 			try
 			{
-				return Task.FromResult<bool>(false);
+				return Task.FromResult<bool>(SubstituteValuesIfNecessary(entity, id, values, persister, source));
 			}
 			catch (Exception ex)
 			{

src/NHibernate/Async/Event/Default/DirtyCollectionSearchVisitor.cs

@@ -26,35 +26,7 @@ internal override Task<object> ProcessCollectionAsync(object collection, Collect
 		{
 			try
 			{
-				if (collection != null)
-				{
-					ISessionImplementor session = Session;
-					IPersistentCollection persistentCollection;
-					if (type.IsArrayType)
-					{
-						persistentCollection = session.PersistenceContext.GetCollectionHolder(collection);
-					// if no array holder we found an unwrappered array (this can't occur,
-					// because we now always call wrap() before getting to here)
-					// return (ah==null) ? true : searchForDirtyCollections(ah, type);
-					}
-					else
-					{
-						// if not wrappered yet, its dirty (this can't occur, because
-						// we now always call wrap() before getting to here)
-						// return ( ! (obj instanceof PersistentCollection) ) ?
-						//true : searchForDirtyCollections( (PersistentCollection) obj, type );
-						persistentCollection = (IPersistentCollection)collection;
-					}
-
-					if (persistentCollection.IsDirty)
-					{
-						//we need to check even if it was not initialized, because of delayed adds!
-						dirty = true;
-						return Task.FromResult<object>(null); //NOTE: EARLY EXIT!
-					}
-				}
-
-				return Task.FromResult<object>(null);
+				return Task.FromResult<object>(ProcessCollection(collection, type));
 			}
 			catch (Exception ex)
 			{

src/NHibernate/Async/Event/Default/EvictVisitor.cs

@@ -28,9 +28,7 @@ internal override Task<object> ProcessCollectionAsync(object collection, Collect
 		{
 			try
 			{
-				if (collection != null)
-					EvictCollection(collection, type);
-				return Task.FromResult<object>(null);
+				return Task.FromResult<object>(ProcessCollection(collection, type));
 			}
 			catch (Exception ex)
 			{

src/NHibernate/Async/Event/Default/OnLockVisitor.cs

@@ -27,52 +27,7 @@ internal override Task<object> ProcessCollectionAsync(object collection, Collect
 		{
 			try
 			{
-				ISessionImplementor session = Session;
-				ICollectionPersister persister = session.Factory.GetCollectionPersister(type.Role);
-				if (collection == null)
-				{
-				//do nothing
-				}
-				else
-				{
-					IPersistentCollection persistentCollection = collection as IPersistentCollection;
-					if (persistentCollection != null)
-					{
-						if (persistentCollection.SetCurrentSession(session))
-						{
-							if (IsOwnerUnchanged(persistentCollection, persister, ExtractCollectionKeyFromOwner(persister)))
-							{
-								// a "detached" collection that originally belonged to the same entity
-								if (persistentCollection.IsDirty)
-								{
-									return Task.FromException<object>(new HibernateException("reassociated object has dirty collection: " + persistentCollection.Role));
-								}
-
-								ReattachCollection(persistentCollection, type);
-							}
-							else
-							{
-								// a "detached" collection that belonged to a different entity
-								return Task.FromException<object>(new HibernateException("reassociated object has dirty collection reference: " + persistentCollection.Role));
-							}
-						}
-						else
-						{
-							// a collection loaded in the current session
-							// can not possibly be the collection belonging
-							// to the entity passed to update()
-							return Task.FromException<object>(new HibernateException("reassociated object has dirty collection reference: " + persistentCollection.Role));
-						}
-					}
-					else
-					{
-						// brand new collection
-						//TODO: or an array!! we can't lock objects with arrays now??
-						return Task.FromException<object>(new HibernateException("reassociated object has dirty collection reference (or an array)"));
-					}
-				}
-
-				return Task.FromResult<object>(null);
+				return Task.FromResult<object>(ProcessCollection(collection, type));
 			}
 			catch (Exception ex)
 			{

src/NHibernate/Async/Event/Default/OnReplicateVisitor.cs

@@ -26,40 +26,7 @@ internal override Task<object> ProcessCollectionAsync(object collection, Collect
 		{
 			try
 			{
-				if (collection == CollectionType.UnfetchedCollection)
-				{
-					return Task.FromResult<object>(null);
-				}
-
-				IEventSource session = Session;
-				ICollectionPersister persister = session.Factory.GetCollectionPersister(type.Role);
-				if (isUpdate)
-				{
-					RemoveCollection(persister, ExtractCollectionKeyFromOwner(persister), session);
-				}
-
-				IPersistentCollection wrapper = collection as IPersistentCollection;
-				if (wrapper != null)
-				{
-					wrapper.SetCurrentSession(session);
-					if (wrapper.WasInitialized)
-					{
-						session.PersistenceContext.AddNewCollection(persister, wrapper);
-					}
-					else
-					{
-						ReattachCollection(wrapper, type);
-					}
-				}
-				else
-				{
-				// otherwise a null or brand new collection
-				// this will also (inefficiently) handle arrays, which
-				// have no snapshot, so we can't do any better
-				//processArrayOrNewCollection(collection, type);
-				}
-
-				return Task.FromResult<object>(null);
+				return Task.FromResult<object>(ProcessCollection(collection, type));
 			}
 			catch (Exception ex)
 			{

src/NHibernate/Async/Event/Default/OnUpdateVisitor.cs

@@ -26,46 +26,7 @@ internal override Task<object> ProcessCollectionAsync(object collection, Collect
 		{
 			try
 			{
-				if (collection == CollectionType.UnfetchedCollection)
-				{
-					return Task.FromResult<object>(null);
-				}
-
-				IEventSource session = Session;
-				ICollectionPersister persister = session.Factory.GetCollectionPersister(type.Role);
-				object collectionKey = ExtractCollectionKeyFromOwner(persister);
-				IPersistentCollection wrapper = collection as IPersistentCollection;
-				if (wrapper != null)
-				{
-					if (wrapper.SetCurrentSession(session))
-					{
-						//a "detached" collection!
-						if (!IsOwnerUnchanged(wrapper, persister, collectionKey))
-						{
-							// if the collection belonged to a different entity,
-							// clean up the existing state of the collection
-							RemoveCollection(persister, collectionKey, session);
-						}
-
-						ReattachCollection(wrapper, type);
-					}
-					else
-					{
-						// a collection loaded in the current session
-						// can not possibly be the collection belonging
-						// to the entity passed to update()
-						RemoveCollection(persister, collectionKey, session);
-					}
-				}
-				else
-				{
-					// null or brand new collection
-					// this will also (inefficiently) handle arrays, which have
-					// no snapshot, so we can't do any better
-					RemoveCollection(persister, collectionKey, session);
-				}
-
-				return Task.FromResult<object>(null);
+				return Task.FromResult<object>(ProcessCollection(collection, type));
 			}
 			catch (Exception ex)
 			{

src/NHibernate/Async/Event/Default/WrapVisitor.cs

@@ -40,21 +40,7 @@ internal override Task<object> ProcessCollectionAsync(object collection, Collect
 		{
 			try
 			{
-				IPersistentCollection coll = collection as IPersistentCollection;
-				if (coll != null)
-				{
-					ISessionImplementor session = Session;
-					if (coll.SetCurrentSession(session))
-					{
-						ReattachCollection(coll, collectionType);
-					}
-
-					return Task.FromResult<object>(null);
-				}
-				else
-				{
-					return Task.FromResult<object>(ProcessArrayOrNewCollection(collection, collectionType));
-				}
+				return Task.FromResult<object>(ProcessCollection(collection, collectionType));
 			}
 			catch (Exception ex)
 			{

src/NHibernate/Async/Id/AbstractPostInsertGenerator.cs

@@ -33,7 +33,7 @@ public Task<object> GenerateAsync(ISessionImplementor s, object obj)
 		{
 			try
 			{
-				return Task.FromResult<object>(IdentifierGeneratorFactory.PostInsertIndicator);
+				return Task.FromResult<object>(Generate(s, obj));
 			}
 			catch (Exception ex)
 			{

src/NHibernate/Async/Id/Assigned.cs

@@ -44,13 +44,7 @@ public Task<object> GenerateAsync(ISessionImplementor session, object obj)
 			}
 			try
 			{
-				object id = session.GetEntityPersister(entityName, obj).GetIdentifier(obj);
-				if (id == null)
-				{
-					return Task.FromException<object>(new IdentifierGenerationException("ids for this class must be manually assigned before calling save(): " + obj.GetType().FullName));
-				}
-
-				return Task.FromResult<object>(id);
+				return Task.FromResult<object>(Generate(session, obj));
 			}
 			catch (Exception ex)
 			{

src/NHibernate/Async/Id/CounterGenerator.cs

@@ -25,7 +25,7 @@ public Task<object> GenerateAsync(ISessionImplementor cache, object obj)
 		{
 			try
 			{
-				return Task.FromResult<object>(unchecked ((DateTime.Now.Ticks << 16) + Count));
+				return Task.FromResult<object>(Generate(cache, obj));
 			}
 			catch (Exception ex)
 			{