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; } } }