WIP Add support for BeginTransactionAsync

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "csharpasyncgenerator.tool": {
-      "version": "0.20.1",
+      "version": "0.21.0",
       "commands": [
         "async-generator"
       ]
@@ -15,4 +15,4 @@
       ]
     }
   }
-}
+}

src/AsyncGenerator.yml

@@ -1,13 +1,13 @@
-projects:
+projects:
 - filePath: NHibernate/NHibernate.csproj
-  targetFramework: netcoreapp2.0
+  targetFramework: netcoreapp2.1
   concurrentRun: true
   applyChanges: true
   suppressDiagnosticFailures:
   - 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:
+    - rule: BeginTransactionAsync
     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,61 @@
+//------------------------------------------------------------------------------
+// <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 Task<DbTransaction> BeginTransactionAsync(IsolationLevel isolationLevel, DbConnection connection, CancellationToken cancellationToken)
+		{
+			if (cancellationToken.IsCancellationRequested)
+			{
+				return Task.FromCanceled<DbTransaction>(cancellationToken);
+			}
+			try
+			{
+				if (isolationLevel == IsolationLevel.Unspecified)
+				{
+					return connection.BeginTransactionAsync(cancellationToken);
+				}
+				return connection.BeginTransactionAsync(isolationLevel, cancellationToken);
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<DbTransaction>(ex);
+			}
+		}
+
+		#if NETFX
+		#else
+
+		#endif
+	}
+}

src/NHibernate/Async/Driver/DriverExtensions.cs

@@ -0,0 +1,60 @@
+//------------------------------------------------------------------------------
+// <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 Task<DbTransaction> BeginTransactionAsync(this IDriver driver, IsolationLevel isolationLevel, DbConnection connection, CancellationToken cancellationToken)
+		{
+			if (cancellationToken.IsCancellationRequested)
+			{
+				return Task.FromCanceled<DbTransaction>(cancellationToken);
+			}
+			try
+			{
+				if (driver is DriverBase driverBase)
+				{
+					return driverBase.BeginTransactionAsync(isolationLevel, connection, cancellationToken);
+				}
+
+				// 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 connection.BeginTransactionAsync(cancellationToken);
+				}
+				return connection.BeginTransactionAsync(isolationLevel, cancellationToken);
+			}
+			catch (System.Exception ex)
+			{
+				return Task.FromException<DbTransaction>(ex);
+			}
+		}
+	}
+}

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.