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.