public async Task CommitTransactionAsync(IDbContextTransaction transaction)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
if (transaction != _contextTransaction)
{
throw new InvalidOperationException($"Transaction {transaction.TransactionId} is not current");
}
try
{
await SaveChangesAsync();
await transaction.CommitAsync();
}
catch
{
await RollbackTransactionAsync();
throw;
}
finally
{
if (_contextTransaction != null)
{
await _contextTransaction.DisposeAsync();
_contextTransaction = null;
}
}
}
public async Task CommitTransactionAsync(IDbContextTransaction transaction, CancellationToken cancellationToken = default)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
if (transaction != currentTransaction)
{
throw new InvalidOperationException($"Transaction {transaction.TransactionId} is not current");
}
try
{
await transaction.CommitAsync(cancellationToken);
}
catch
{
await RollbackTransaction();
throw;
}
finally
{
if (currentTransaction != null)
{
await currentTransaction.DisposeAsync();
currentTransaction = null;
}
}
}
public async Task CommitAsync(CancellationToken cancellationToken = default)
{
if (_context == null)
{
throw new ArgumentNullException(nameof(_context));
}
if (_dbContextTransaction == null)
{
throw new ArgumentNullException(nameof(_dbContextTransaction));
}
try
{
await _context.SaveChangesAsync(cancellationToken);
await _dbContextTransaction.CommitAsync(cancellationToken);
}
catch
{
await _dbContextTransaction.RollbackAsync(cancellationToken);
throw;
}
finally
{
if (_dbContextTransaction != null)
{
await _dbContextTransaction.DisposeAsync();
_dbContextTransaction = null;
}
}
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual async Task ExecuteNonQueryAsync(
IEnumerable <MigrationCommand> migrationCommands,
IRelationalConnection connection,
CancellationToken cancellationToken = default)
{
Check.NotNull(migrationCommands, nameof(migrationCommands));
Check.NotNull(connection, nameof(connection));
var transactionScope = new TransactionScope(TransactionScopeOption.Suppress, TransactionScopeAsyncFlowOption.Enabled);
try
{
await connection.OpenAsync(cancellationToken);
try
{
IDbContextTransaction transaction = null;
try
{
foreach (var command in migrationCommands)
{
if (transaction == null &&
!command.TransactionSuppressed)
{
transaction = await connection.BeginTransactionAsync(cancellationToken);
}
if (transaction != null &&
command.TransactionSuppressed)
{
transaction.Commit();
await transaction.DisposeAsync();
transaction = null;
}
await command.ExecuteNonQueryAsync(connection, cancellationToken : cancellationToken);
}
transaction?.Commit();
}
finally
{
if (transaction != null)
{
await transaction.DisposeAsync();
}
}
}
finally
{
await connection.CloseAsync();
}
}
finally
{
await transactionScope.DisposeAsyncIfAvailable();
}
}
public async Task CommitAsync(CancellationToken cancellationToken = default)
{
await _transaction.CommitAsync();
await _transaction.DisposeAsync();
_transaction = null;
}
public async Task SaveTransactionAsync()
{
await _dbTransaction.CommitAsync();
await _dbTransaction.DisposeAsync();
_dbTransaction = null;
}
private async Task CommitAsync()
{
while (this.HasChanges())
{
await this.Context.SaveChangesAsync();
}
await _transaction.CommitAsync();
await _transaction.DisposeAsync();
}
public async Task CommitAsync()
{
try
{
await SaveChangesAsync();
await _transaction.CommitAsync();
}
finally
{
await _transaction.DisposeAsync();
}
}
public Task CommitAsync()
{
return(Task.Run(async() =>
{
try
{
await SaveChangesAsync();
await _transaction.CommitAsync();
}
finally
{
await _transaction.DisposeAsync();
}
}));
}
public async ValueTask DisposeAsync()
{
if (_transaction != null)
{
await _transaction.DisposeAsync();
}
}
public async Task EndTransaction()
{
if (transaction != null)
{
await transaction.DisposeAsync();
}
}
public async ValueTask DisposeAsync()
{
if (!_existingTransaction)
{
await _transaction.DisposeAsync();
}
}
public async Task <HoAMember> Create(HoAMember member)
{
//Open a transaction. A line of communication to the database.
IDbContextTransaction transaction = await DbContext.Database.BeginTransactionAsync();
try
{
await DbContext.AddAsync(member);
await DbContext.SaveChangesAsync();
transaction.Commit();
}
finally
{
if (transaction != null)
{
await transaction.DisposeAsync();
}
}
HoAMember obj = await this.Read(member.Id);
HoAMember product = obj;
obj = default;
return(product);
}
public async ValueTask DisposeAsync()
{
await _transaction.RollbackAsync().ConfigureAwait(false);
await _transaction.DisposeAsync().ConfigureAwait(false);
_scope.Dispose();
}
private async Task RollbackAsync(CancellationToken cancellationToken = default)
{
if (_transaction != null)
{
await _transaction.RollbackAsync(cancellationToken);
await _transaction.DisposeAsync();
}
}
public async Task CommitAsync(Guid transactionId, CancellationToken cancellationToken = new CancellationToken())
{
if (_transaction == null || transactionId != _transactionId)
{
return;
}
try
{
await base.SaveChangesAsync(cancellationToken);
await _transaction.CommitAsync(cancellationToken);
}
finally
{
await _transaction.DisposeAsync();
}
}
/// <inheritdoc />
protected override async ValueTask DisposeAsync(bool disposing)
{
await base.DisposeAsync(disposing).ConfigureAwait(false);
if (disposing)
{
await _innerTx.DisposeAsync().ConfigureAwait(false);
}
}
public async Task DisposeTransactionAsync()
{
if (_transaction != null)
{
await _transaction.DisposeAsync();
_transaction = null;
}
}
public async Task Finish()
{
if (transaction != null)
{
await transaction?.RollbackAsync();
await transaction.DisposeAsync();
}
}
public ValueTask DisposeAsync()
{
if (TransactionId == Guid.Empty)
{
return(new ValueTask(Task.CompletedTask));
}
return(_transaction.DisposeAsync());
}
private async Task DisposableAsync()
{
if (_transaction != null)
{
await _transaction.DisposeAsync();
_transaction = null;
}
}
public ValueTask DisposeAsync()
{
if (_wasDisposed)
{
return(new ValueTask());
}
_wasDisposed = true;
return(_efDbContextTransaction.DisposeAsync());
}
public async Task CommitTransaction()
{
/*
* do not open transaction here, because if during the request
* nothing was changed(only select queries were run), we don't
* want to open and commit an empty transaction -calling SaveChanges()
* on _transactionProvider will not send any sql to database in such case
*/
await DbContext.SaveChangesAsync();
if (_transaction == null)
{
return;
}
await _transaction.CommitAsync();
await _transaction.DisposeAsync();
_transaction = null;
}
private async Task RollbackTransactionAsync(IDbContextTransaction transaction, CancellationToken cancellationToken)
{
await transaction.RollbackToSavepointAsync(SavepointName, cancellationToken);
_logger.LogInformation("Action='{ActionName}' Message='Transaction rollback to the savepoint.' TransactionId='{TransactionId}' Savepoint='{Savepoint}'", ActionName, transaction !.TransactionId, SavepointName);
if (!_isNestedTransaction)
{
await transaction.DisposeAsync();
}
}
public virtual async Task CommitAsync(CancellationToken token = default)
{
try
{
await SaveChangesAsync(token);
if (Transaction != null)
{
await Transaction.CommitAsync(token);
}
}
finally
{
if (Transaction != null)
{
await Transaction.DisposeAsync();
Transaction = null;
}
}
}
protected override async ValueTask DisposeAsync(bool disposing)
{
if (_transaction != null)
{
await _transaction.DisposeAsync();
}
if (_dbContext != null)
{
await _dbContext.DisposeAsync();
}
}
public async ValueTask DisposeAsync()
{
using (await locker.LockAsync())
{
if (!committed)
{
await transaction.RollbackAsync();
}
await transaction.DisposeAsync();
await context.DisposeAsync();
}
}
private async Task CommitTransactionAsync(IDbContextTransaction transaction, CancellationToken cancellationToken)
{
if (_isNestedTransaction)
{
_logger.LogInformation("Action='{ActionName}' Message='Is nested transaction. Commit action skipped.' TransactionId='{TransactionId}'", ActionName, transaction !.TransactionId);
return;
}
await transaction.CommitAsync(cancellationToken);
await transaction.DisposeAsync();
_logger.LogInformation("Action='{ActionName}' Message='Transaction committed.' TransactionId='{TransactionId}'", ActionName, transaction !.TransactionId);
}
public async Task CommitTransactionAsync()
{
try
{
await _dbContext.SaveChangesAsync();
_currentTransaction?.Commit();
}
catch
{
await RollbackTransactionAsync();
throw;
}
finally
{
if (_currentTransaction != null)
{
await _currentTransaction.DisposeAsync();
_currentTransaction = null;
}
}
}
public async Task CommitTransactionAsync()
{
try
{
await SaveChangesAsync();
await currentTransaction.CommitAsync();
}
catch (Exception e)
{
await RollBackTransactionAsync();
throw;
}
finally
{
if (currentTransaction != null)
{
await currentTransaction.DisposeAsync();
currentTransaction = null;
}
}
}
