WIP Add support for BeginTransactionAsync

src/AsyncGenerator.yml

@@ -1,4 +1,4 @@
-projects:
+projects:
 - filePath: NHibernate/NHibernate.csproj
   targetFramework: netcoreapp2.0
   concurrentRun: true
@@ -7,7 +7,7 @@
   - pattern: ^.*(Hql\.g).*$
   analyzation:
     methodConversion:
-#TODO 6.0: Remove ignore rule for IQueryBatchItem.ProcessResults
+      #TODO 6.0: Remove ignore rule for IQueryBatchItem.ProcessResults
     - conversion: Ignore
       name: ProcessResults
       containingTypeName: IQueryBatchItem
@@ -62,7 +62,7 @@
     - conversion: Ignore
       name: CloseSessionFromSystemTransaction
       containingTypeName: ISessionImplementor
-# TODO 6.0: Remove ignore rule for IStatelessSession.Close
+      # TODO 6.0: Remove ignore rule for IStatelessSession.Close
     - conversion: Ignore
       name: Close
       containingTypeName: IStatelessSession
@@ -114,7 +114,7 @@
     - conversion: Ignore
       name: GetEnumerator
       containingTypeName: IFutureEnumerable
-# TODO 6.0: Consider if ComputeFlattenedParameters should remain ignored or not
+    # TODO 6.0: Consider if ComputeFlattenedParameters should remain ignored or not
     - conversion: Ignore
       name: ComputeFlattenedParameters
       containingTypeName: SqlQueryImpl
@@ -124,12 +124,17 @@
     - conversion: ToAsync
       name: ExecuteNonQuery
       containingTypeName: IBatcher
+    - conversion: ToAsync
+      name: BeginTransaction
+      containingTypeName: DriverBase
     - conversion: ToAsync
       rule: EventListener
     - conversion: ToAsync
       rule: Cache
     - conversion: ToAsync
       rule: TransactionCompletion
+    alwaysAwait:
+    - name: BeginTransaction
     typeConversion:
     - conversion: Ignore
       name: EnumerableImpl
@@ -139,6 +144,10 @@
     - conversion: Ignore
       name: DependentContext
       containingTypeName: AdoNetWithSystemTransactionFactory
+    asyncExtensionMethods:
+      projectFiles:
+      - fileName: AsyncExtensions.cs
+        projectName: NHibernate
     ignoreSearchForAsyncCounterparts:
     - name: GetFieldValue
     - name: IsDBNull
@@ -212,6 +221,8 @@
       projectFiles:
       - fileName: LinqExtensionMethods.cs
         projectName: NHibernate
+      - fileName: AsyncExtensions.cs
+        projectName: NHibernate
     typeConversion:
     - conversion: Ignore
       name: ObjectAssert
@@ -307,6 +318,9 @@ methodRules:
 - filters:
   - hasAttributeName: ObsoleteAttribute
   name: Obsolete
+- filters:
+  - containingTypeName: AsyncExtensions
+  name: BeginTransactionAsync
 typeRules:
 - filters:
   - containingAssemblyName: NHibernate

src/NHibernate.Test/Async/TransactionTest/TransactionNotificationFixture.cs

@@ -138,6 +138,16 @@ public async Task ShouldNotifyAfterTransactionWithOwnConnectionAsync(bool usePre
 	public partial class CustomTransaction : ITransaction
 	{
 
+		public Task BeginAsync(CancellationToken cancellationToken = default(CancellationToken))
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task BeginAsync(IsolationLevel isolationLevel, CancellationToken cancellationToken = default(CancellationToken))
+		{
+			throw new NotImplementedException();
+		}
+
 		public Task CommitAsync(CancellationToken cancellationToken = default(CancellationToken))
 		{
 			throw new NotImplementedException();

src/NHibernate.Test/TypesTest/AbstractDateTimeTypeFixture.cs

@@ -548,7 +548,7 @@ protected DateTimeKind GetTypeKind()
 		}
 	}
 
-	public class ClientDriverWithParamsStats : IDriver
+	public partial class ClientDriverWithParamsStats : IDriver
 	{
 		private readonly Dictionary<SqlType, int> _usedSqlTypes = new Dictionary<SqlType, int>();
 		private readonly Dictionary<DbType, int> _usedDbTypes = new Dictionary<DbType, int>();

src/NHibernate/AdoNet/AsyncExtensions.cs

@@ -0,0 +1,43 @@
+#if NETFX || NETSTANDARD2_0 || NETCOREAPP2_0
+using System;
+using System.Data;
+using System.Data.Common;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NHibernate
+{
+	internal static class AsyncExtensions
+	{
+		public static Task<DbTransaction> BeginTransactionAsync(this DbConnection connection, CancellationToken cancellationToken = default)
+		{
+			if (cancellationToken.IsCancellationRequested)
+				return Task.FromCanceled<DbTransaction>(cancellationToken);
+
+			try
+			{
+				return Task.FromResult(connection.BeginTransaction());
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<DbTransaction>(ex);
+			}
+		}
+
+		public static Task<DbTransaction> BeginTransactionAsync(this DbConnection connection, IsolationLevel isolationLevel, CancellationToken cancellationToken = default)
+		{
+			if (cancellationToken.IsCancellationRequested)
+				return Task.FromCanceled<DbTransaction>(cancellationToken);
+
+			try
+			{
+				return Task.FromResult(connection.BeginTransaction(isolationLevel));
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<DbTransaction>(ex);
+			}
+		}
+	}
+}
+#endif

src/NHibernate/AdoNet/ResultSetWrapper.cs

@@ -13,7 +13,7 @@ namespace NHibernate.AdoNet
 	/// and Postgres). 
 	/// </summary>
 	/// <seealso cref="IDataRecord.GetOrdinal"/>
-	public class ResultSetWrapper : DbDataReader
+	public partial class ResultSetWrapper : DbDataReader
 	{
 		private DbDataReader rs;
 		private readonly ColumnNameCache columnNameCache;

src/NHibernate/Async/AdoNet/ConnectionManager.cs

@@ -106,6 +106,22 @@ async Task<DbConnection> InternalGetConnectionAsync()
 			}
 		}
 
+		public async Task<ITransaction> BeginTransactionAsync(IsolationLevel isolationLevel, CancellationToken cancellationToken)
+		{
+			cancellationToken.ThrowIfCancellationRequested();
+			EnsureTransactionIsCreated();
+			await (_transaction.BeginAsync(isolationLevel, cancellationToken)).ConfigureAwait(false);
+			return _transaction;
+		}
+
+		public async Task<ITransaction> BeginTransactionAsync(CancellationToken cancellationToken)
+		{
+			cancellationToken.ThrowIfCancellationRequested();
+			EnsureTransactionIsCreated();
+			await (_transaction.BeginAsync(cancellationToken)).ConfigureAwait(false);
+			return _transaction;
+		}
+
 		public async Task<DbCommand> CreateCommandAsync(CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();

src/NHibernate/Async/Driver/DriverBase.cs

@@ -0,0 +1,51 @@
+//------------------------------------------------------------------------------
+// <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 System.Data;
+using System.Data.Common;
+using System.Linq;
+using NHibernate.Engine;
+using NHibernate.SqlCommand;
+using NHibernate.SqlTypes;
+using NHibernate.Util;
+using Environment = NHibernate.Cfg.Environment;
+
+namespace NHibernate.Driver
+{
+	using System.Threading.Tasks;
+	using System.Threading;
+	public abstract partial class DriverBase : IDriver, ISqlParameterFormatter
+	{
+
+		/// <summary>
+		/// Begin an ADO <see cref="DbTransaction" />.
+		/// </summary>
+		/// <param name="isolationLevel">The isolation level requested for the transaction.</param>
+		/// <param name="connection">The connection on which to start the transaction.</param>
+		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
+		/// <returns>The started <see cref="DbTransaction" />.</returns>
+		public virtual async Task<DbTransaction> BeginTransactionAsync(IsolationLevel isolationLevel, DbConnection connection, CancellationToken cancellationToken)
+		{
+			cancellationToken.ThrowIfCancellationRequested();
+			if (isolationLevel == IsolationLevel.Unspecified)
+			{
+				return await (connection.BeginTransactionAsync(cancellationToken)).ConfigureAwait(false);
+			}
+			return await (connection.BeginTransactionAsync(isolationLevel, cancellationToken)).ConfigureAwait(false);
+		}
+
+		#if NETFX
+		#else
+
+		#endif
+	}
+}

src/NHibernate/Async/Driver/DriverExtensions.cs

@@ -0,0 +1,50 @@
+//------------------------------------------------------------------------------
+// <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.Data;
+using System.Data.Common;
+using NHibernate.AdoNet;
+using NHibernate.SqlTypes;
+using NHibernate.Util;
+
+namespace NHibernate.Driver
+{
+	using System.Threading.Tasks;
+	using System.Threading;
+	public static partial class DriverExtensions
+	{
+
+		// 6.0 TODO: merge into IDriver
+		/// <summary>
+		/// Begin an ADO <see cref="DbTransaction" />.
+		/// </summary>
+		/// <param name="driver">The driver.</param>
+		/// <param name="isolationLevel">The isolation level requested for the transaction.</param>
+		/// <param name="connection">The connection on which to start the transaction.</param>
+		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
+		/// <returns>The started <see cref="DbTransaction" />.</returns>
+		public static async Task<DbTransaction> BeginTransactionAsync(this IDriver driver, IsolationLevel isolationLevel, DbConnection connection, CancellationToken cancellationToken)
+		{
+			cancellationToken.ThrowIfCancellationRequested();
+			if (driver is DriverBase driverBase)
+			{
+				return await (driverBase.BeginTransactionAsync(isolationLevel, connection, cancellationToken)).ConfigureAwait(false);
+			}
+
+			// So long for custom drivers not deriving from DriverBase, they will have to wait for 6.0 if they
+			// need the feature.
+			if (isolationLevel == IsolationLevel.Unspecified)
+			{
+				return await (connection.BeginTransactionAsync(cancellationToken)).ConfigureAwait(false);
+			}
+			return await (connection.BeginTransactionAsync(isolationLevel, cancellationToken)).ConfigureAwait(false);
+		}
+	}
+}

src/NHibernate/Async/ITransaction.cs

@@ -11,14 +11,26 @@
 using System;
 using System.Data;
 using System.Data.Common;
+using System.Threading.Tasks;
 using NHibernate.Transaction;
 
 namespace NHibernate
 {
-	using System.Threading.Tasks;
 	using System.Threading;
 	public partial interface ITransaction : IDisposable
 	{
+		/// <summary>
+		/// Begin the transaction with the default isolation level.
+		/// </summary>
+		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
+		Task BeginAsync(CancellationToken cancellationToken = default(CancellationToken));
+
+		/// <summary>
+		/// Begin the transaction with the specified isolation level.
+		/// </summary>
+		/// <param name="isolationLevel">Isolation level of the transaction</param>
+		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
+		Task BeginAsync(IsolationLevel isolationLevel, CancellationToken cancellationToken = default(CancellationToken));
 
 		/// <summary>
 		/// Flush the associated <c>ISession</c> and end the unit of work.

src/NHibernate/Async/Impl/AbstractSessionImpl.cs

@@ -212,6 +212,49 @@ protected async Task AfterOperationAsync(bool success, CancellationToken cancell
 			}
 		}
 
+		/// <summary>
+		/// Begin a NHibernate transaction
+		/// </summary>
+		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
+		/// <returns>A NHibernate transaction</returns>
+		public async Task<ITransaction> BeginTransactionAsync(CancellationToken cancellationToken)
+		{
+			cancellationToken.ThrowIfCancellationRequested();
+			using (BeginProcess())
+			{
+				if (IsTransactionCoordinatorShared)
+				{
+					// Todo : should seriously consider not allowing a txn to begin from a child session
+					//      can always route the request to the root session...
+					Log.Warn("Transaction started on non-root session");
+				}
+
+				return await (ConnectionManager.BeginTransactionAsync(cancellationToken)).ConfigureAwait(false);
+			}
+		}
+
+		/// <summary>
+		/// Begin a NHibernate transaction with the specified isolation level
+		/// </summary>
+		/// <param name="isolationLevel">The isolation level</param>
+		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
+		/// <returns>A NHibernate transaction</returns>
+		public async Task<ITransaction> BeginTransactionAsync(IsolationLevel isolationLevel, CancellationToken cancellationToken)
+		{
+			cancellationToken.ThrowIfCancellationRequested();
+			using (BeginProcess())
+			{
+				if (IsTransactionCoordinatorShared)
+				{
+					// Todo : should seriously consider not allowing a txn to begin from a child session
+					//      can always route the request to the root session...
+					Log.Warn("Transaction started on non-root session");
+				}
+
+				return await (ConnectionManager.BeginTransactionAsync(isolationLevel, cancellationToken)).ConfigureAwait(false);
+			}
+		}
+
 		public abstract Task<IQuery> CreateFilterAsync(object collection, IQueryExpression queryExpression, CancellationToken cancellationToken);
 
 		public abstract Task<IEnumerable> EnumerableAsync(IQueryExpression queryExpression, QueryParameters queryParameters, CancellationToken cancellationToken);

src/NHibernate/Async/Transaction/AdoNetTransactionFactory.cs

@@ -51,7 +51,7 @@ async Task InternalExecuteWorkInIsolationAsync()
 
 					if (transacted)
 					{
-						trans = connection.BeginTransaction();
+						trans = await (connection.BeginTransactionAsync(cancellationToken)).ConfigureAwait(false);
 					}
 
 					await (work.DoWorkAsync(connection, trans, cancellationToken)).ConfigureAwait(false);