NH-2088 - Generate async code

Author: hazzik

src/NHibernate/Action/BulkOperationCleanupAction.cs

@@ -10,7 +10,7 @@ namespace NHibernate.Action
 	/// Implementation of BulkOperationCleanupAction.
 	/// </summary>
 	[Serializable]
-	public class BulkOperationCleanupAction: IExecutable
+	public partial class BulkOperationCleanupAction: IExecutable
 	{
 		private readonly ISessionImplementor session;
 		private readonly HashSet<string> affectedEntityNames = new HashSet<string>();

src/NHibernate/Action/CollectionAction.cs

@@ -14,7 +14,7 @@ namespace NHibernate.Action
 	/// Any action relating to insert/update/delete of a collection
 	/// </summary>
 	[Serializable]
-	public abstract class CollectionAction : IExecutable, IComparable<CollectionAction>, IDeserializationCallback
+	public abstract partial class CollectionAction : IExecutable, IComparable<CollectionAction>, IDeserializationCallback
 	{
 		private readonly object key;
 		private object finalKey;

src/NHibernate/Action/CollectionRecreateAction.cs

@@ -8,7 +8,7 @@
 namespace NHibernate.Action
 {
 	[Serializable]
-	public sealed class CollectionRecreateAction : CollectionAction
+	public sealed partial class CollectionRecreateAction : CollectionAction
 	{
 		public CollectionRecreateAction(IPersistentCollection collection, ICollectionPersister persister, object key, ISessionImplementor session)
 			: base(persister, collection, key, session) { }

src/NHibernate/Action/CollectionRemoveAction.cs

@@ -8,7 +8,7 @@
 namespace NHibernate.Action
 {
 	[Serializable]
-	public sealed class CollectionRemoveAction : CollectionAction
+	public sealed partial class CollectionRemoveAction : CollectionAction
 	{
 		private readonly bool emptySnapshot;
 		private readonly object affectedOwner;

src/NHibernate/Action/CollectionUpdateAction.cs

@@ -11,7 +11,7 @@
 namespace NHibernate.Action
 {
 	[Serializable]
-	public sealed class CollectionUpdateAction : CollectionAction
+	public sealed partial class CollectionUpdateAction : CollectionAction
 	{
 		private readonly bool emptySnapshot;
 

src/NHibernate/Action/EntityAction.cs

@@ -13,7 +13,7 @@ namespace NHibernate.Action
 	/// instance.
 	/// </summary>
 	[Serializable]
-	public abstract class EntityAction : IExecutable, IComparable<EntityAction>, IDeserializationCallback
+	public abstract partial class EntityAction : IExecutable, IComparable<EntityAction>, IDeserializationCallback
 	{
 		private readonly string entityName;
 		private readonly object id;

src/NHibernate/Action/EntityDeleteAction.cs

@@ -9,7 +9,7 @@
 namespace NHibernate.Action
 {
 	[Serializable]
-	public sealed class EntityDeleteAction : EntityAction
+	public sealed partial class EntityDeleteAction : EntityAction
 	{
 		private readonly object[] state;
 		private readonly object version;

src/NHibernate/Action/EntityIdentityInsertAction.cs

@@ -7,7 +7,7 @@
 namespace NHibernate.Action
 {
 	[Serializable]
-	public sealed class EntityIdentityInsertAction : EntityAction
+	public sealed partial class EntityIdentityInsertAction : EntityAction
 	{
 		private readonly object lockObject = new object();
 		private readonly object[] state;

src/NHibernate/Action/EntityInsertAction.cs

@@ -9,7 +9,7 @@
 namespace NHibernate.Action
 {
 	[Serializable]
-	public sealed class EntityInsertAction : EntityAction
+	public sealed partial class EntityInsertAction : EntityAction
 	{
 		private readonly object[] state;
 		private object version;

src/NHibernate/Action/EntityUpdateAction.cs

@@ -11,7 +11,7 @@
 namespace NHibernate.Action
 {
 	[Serializable]
-	public sealed class EntityUpdateAction : EntityAction
+	public sealed partial class EntityUpdateAction : EntityAction
 	{
 		private readonly object[] state;
 		private readonly object[] previousState;

src/NHibernate/Action/IExecutable.cs

@@ -28,7 +28,7 @@ namespace NHibernate.Action
 	/// Usually, the operation is a database insert/update/delete,
 	/// together with required second-level cache management.
 	/// </summary>
-	public interface IExecutable
+	public partial interface IExecutable
 	{
 		/// <summary>
 		/// What spaces (tables) are affected by this action?

src/NHibernate/AdoNet/AbstractBatcher.cs

@@ -18,7 +18,7 @@ namespace NHibernate.AdoNet
 	/// <summary>
 	/// Manages prepared statements and batching. Class exists to enforce separation of concerns
 	/// </summary>
-	public abstract class AbstractBatcher : IBatcher
+	public abstract partial class AbstractBatcher : IBatcher
 	{
 		protected static readonly IInternalLogger Log = LoggerProvider.LoggerFor(typeof(AbstractBatcher));
 

src/NHibernate/AdoNet/ConnectionManager.cs

@@ -17,7 +17,7 @@ namespace NHibernate.AdoNet
 	/// combined.
 	/// </remarks>
 	[Serializable]
-	public class ConnectionManager : ISerializable, IDeserializationCallback
+	public partial class ConnectionManager : ISerializable, IDeserializationCallback
 	{
 		private static readonly IInternalLogger log = LoggerProvider.LoggerFor(typeof(ConnectionManager));
 

src/NHibernate/AdoNet/MySqlClientBatchingBatcher.cs

@@ -6,7 +6,7 @@
 
 namespace NHibernate.AdoNet
 {
-	public class MySqlClientBatchingBatcher : AbstractBatcher
+	public partial class MySqlClientBatchingBatcher : AbstractBatcher
 	{
 		private int batchSize;
 		private int totalExpectedRowsAffected;

src/NHibernate/AdoNet/NonBatchingBatcher.cs

@@ -9,7 +9,7 @@ namespace NHibernate.AdoNet
 	/// An implementation of the <see cref="IBatcher" /> 
 	/// interface that does no batching.
 	/// </summary>
-	public class NonBatchingBatcher : AbstractBatcher
+	public partial class NonBatchingBatcher : AbstractBatcher
 	{
 		/// <summary>
 		/// Initializes a new instance of the <see cref="NonBatchingBatcher"/> class.

src/NHibernate/AdoNet/OracleDataClientBatchingBatcher.cs

@@ -11,7 +11,7 @@ namespace NHibernate.AdoNet
 	/// Summary description for OracleDataClientBatchingBatcher.
 	/// By Tomer Avissar
 	/// </summary>
-	public class OracleDataClientBatchingBatcher : AbstractBatcher
+	public partial class OracleDataClientBatchingBatcher : AbstractBatcher
 	{
 		private int _batchSize;
 		private int _countOfCommands;

src/NHibernate/AdoNet/SqlClientBatchingBatcher.cs

@@ -7,7 +7,7 @@
 
 namespace NHibernate.AdoNet
 {
-	public class SqlClientBatchingBatcher : AbstractBatcher
+	public partial class SqlClientBatchingBatcher : AbstractBatcher
 	{
 		private int _batchSize;
 		private int _totalExpectedRowsAffected;

src/NHibernate/Async/Action/BulkOperationCleanupAction.cs

@@ -0,0 +1,33 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using System;
+using System.Collections.Generic;
+using NHibernate.Engine;
+using NHibernate.Metadata;
+using NHibernate.Persister.Entity;
+
+namespace NHibernate.Action
+{
+	using System.Threading.Tasks;
+	public partial class BulkOperationCleanupAction: IExecutable
+	{
+
+		#region IExecutable Members
+
+		public Task ExecuteAsync()
+		{
+			return Task.CompletedTask;
+			// nothing to do
+		}
+
+		#endregion
+	}
+}

src/NHibernate/Async/Action/CollectionAction.cs

@@ -0,0 +1,42 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using System;
+using System.Runtime.Serialization;
+using NHibernate.Cache;
+using NHibernate.Cache.Access;
+using NHibernate.Collection;
+using NHibernate.Engine;
+using NHibernate.Impl;
+using NHibernate.Persister.Collection;
+using NHibernate.Util;
+
+namespace NHibernate.Action
+{
+	using System.Threading.Tasks;
+	public abstract partial class CollectionAction : IExecutable, IComparable<CollectionAction>, IDeserializationCallback
+	{
+
+		#region IExecutable Members
+
+		/// <summary>Execute this action</summary>
+		public abstract Task ExecuteAsync();
+
+		#endregion
+
+		#region IComparable<CollectionAction> Members
+
+		#endregion
+
+		#region IDeserializationCallback Members
+
+		#endregion
+	}
+}

src/NHibernate/Async/Action/CollectionRecreateAction.cs

@@ -0,0 +1,81 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using System;
+using System.Diagnostics;
+using NHibernate.Collection;
+using NHibernate.Engine;
+using NHibernate.Event;
+using NHibernate.Persister.Collection;
+
+namespace NHibernate.Action
+{
+	using System.Threading.Tasks;
+	public sealed partial class CollectionRecreateAction : CollectionAction
+	{
+
+		/// <summary> Execute this action</summary>
+		/// <remarks>
+		/// This method is called when a new non-null collection is persisted
+		/// or when an existing (non-null) collection is moved to a new owner
+		/// </remarks>
+		public override async Task ExecuteAsync()
+		{
+			bool statsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
+			Stopwatch stopwatch = null;
+			if (statsEnabled)
+			{
+				stopwatch = Stopwatch.StartNew();
+			}
+			IPersistentCollection collection = Collection;
+
+			await (PreRecreateAsync()).ConfigureAwait(false);
+
+			await (Persister.RecreateAsync(collection, Key, Session)).ConfigureAwait(false);
+
+			Session.PersistenceContext.GetCollectionEntry(collection).AfterAction(collection);
+
+			Evict();
+
+			await (PostRecreateAsync()).ConfigureAwait(false);
+			if (statsEnabled)
+			{
+				stopwatch.Stop();
+				Session.Factory.StatisticsImplementor.RecreateCollection(Persister.Role, stopwatch.Elapsed);
+			}
+		}
+
+		private async Task PreRecreateAsync()
+		{
+			IPreCollectionRecreateEventListener[] preListeners = Session.Listeners.PreCollectionRecreateEventListeners;
+			if (preListeners.Length > 0)
+			{
+				PreCollectionRecreateEvent preEvent = new PreCollectionRecreateEvent(Persister, Collection, (IEventSource)Session);
+				for (int i = 0; i < preListeners.Length; i++)
+				{
+					await (preListeners[i].OnPreRecreateCollectionAsync(preEvent)).ConfigureAwait(false);
+				}
+			}
+		}
+
+		private async Task PostRecreateAsync()
+		{
+			IPostCollectionRecreateEventListener[] postListeners = Session.Listeners.PostCollectionRecreateEventListeners;
+			if (postListeners.Length > 0)
+			{
+				PostCollectionRecreateEvent postEvent = new PostCollectionRecreateEvent(Persister, Collection, (IEventSource)Session);
+				for (int i = 0; i < postListeners.Length; i++)
+				{
+					await (postListeners[i].OnPostRecreateCollectionAsync(postEvent)).ConfigureAwait(false);
+				}
+			}
+		}
+	}
+}

src/NHibernate/Async/Action/CollectionRemoveAction.cs

@@ -0,0 +1,85 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using System;
+using System.Diagnostics;
+using NHibernate.Collection;
+using NHibernate.Engine;
+using NHibernate.Event;
+using NHibernate.Persister.Collection;
+
+namespace NHibernate.Action
+{
+	using System.Threading.Tasks;
+	public sealed partial class CollectionRemoveAction : CollectionAction
+	{
+
+		public override async Task ExecuteAsync()
+		{
+			bool statsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
+			Stopwatch stopwatch = null;
+			if (statsEnabled)
+			{
+				stopwatch = Stopwatch.StartNew();
+			}
+
+			await (PreRemoveAsync()).ConfigureAwait(false);
+
+			if (!emptySnapshot)
+			{
+				await (Persister.RemoveAsync(Key, Session)).ConfigureAwait(false);
+			}
+
+			IPersistentCollection collection = Collection;
+			if (collection != null)
+			{
+				Session.PersistenceContext.GetCollectionEntry(collection).AfterAction(collection);
+			}
+
+			Evict();
+
+			await (PostRemoveAsync()).ConfigureAwait(false);
+
+			if (statsEnabled)
+			{
+				stopwatch.Stop();
+				Session.Factory.StatisticsImplementor.RemoveCollection(Persister.Role, stopwatch.Elapsed);
+			}
+		}
+
+		private async Task PreRemoveAsync()
+		{
+			IPreCollectionRemoveEventListener[] preListeners = Session.Listeners.PreCollectionRemoveEventListeners;
+			if (preListeners.Length > 0)
+			{
+				PreCollectionRemoveEvent preEvent = new PreCollectionRemoveEvent(Persister, Collection, (IEventSource) Session,
+				                                                                 affectedOwner);
+				for (int i = 0; i < preListeners.Length; i++)
+				{
+					await (preListeners[i].OnPreRemoveCollectionAsync(preEvent)).ConfigureAwait(false);
+				}
+			}
+		}
+
+		private async Task PostRemoveAsync()
+		{
+			IPostCollectionRemoveEventListener[] postListeners = Session.Listeners.PostCollectionRemoveEventListeners;
+			if (postListeners.Length > 0)
+			{
+				PostCollectionRemoveEvent postEvent = new PostCollectionRemoveEvent(Persister, Collection, (IEventSource) Session,
+				                                                                    affectedOwner);
+				for (int i = 0; i < postListeners.Length; i++)
+				{
+					await (postListeners[i].OnPostRemoveCollectionAsync(postEvent)).ConfigureAwait(false);
+				}
+			}
+		}
+	}
+}