public async Task CommitAsync(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 base.SaveChangesAsync(cancellationToken); await transaction.CommitAsync(cancellationToken); } catch { Rollback(); throw; } finally { if (_currentTransaction != null) { _currentTransaction.Dispose(); _currentTransaction = null; } } }
public void CommitTransaction() { if (Transaction == null) { throw new InvalidOperationException("Transaction is null!"); } try { Transaction.Commit(); } catch { RollbackTransaction(); throw; } finally { if (Transaction != null) { Transaction.Dispose(); Transaction = null; } } }
public async Task RollbackTransactionAsync() { await Transaction.RollbackAsync(); Transaction?.Dispose(); Transaction = null; }
public async Task CommitTransactionAsync(IDbContextTransaction transaction) { if (transaction == null) { throw new ArgumentNullException(nameof(transaction)); } if (transaction != _currentTransaction) { throw new InvalidOperationException($"Transação {transaction.TransactionId} não é a atual."); } try { var isObjectSaved = await SaveEntitiesAsync(); if (isObjectSaved) { transaction.Commit(); } } catch (Exception ex) { RollbackTransaction(); throw new Exception(ex.Message); } finally { if (_currentTransaction != null) { _currentTransaction.Dispose(); _currentTransaction = null; } } }
public async Task CommitTransactionAsync() { try { await SaveChangesAsync().ConfigureAwait(false); if (_currentTransaction != null) { await _currentTransaction.CommitAsync(); } } catch { RollbackTransaction(); throw; } finally { if (_currentTransaction != null) { _currentTransaction.Dispose(); _currentTransaction = null; } } }
public void Commit() { try { this.BeginTransaction(); foreach (var rawCommand in RawSQlCommandList) { //execute SQL Command WITH params if (rawCommand.ParamsForSql != null) { _tmsDbContext.Database.ExecuteSqlRaw(rawCommand.RawSqlString, rawCommand.ParamsForSql); } //execute SQL Command WITHOUT params else { _tmsDbContext.Database.ExecuteSqlRaw(rawCommand.RawSqlString); } } _tmsDbContext.SaveChanges(); _transaction.Commit(); } catch { this.Rollback(); } finally { //Cleand the current commands so they won't be executed more than once this.RawSQlCommandList = new List <RawSQlCommand>(); _transaction.Dispose(); } }
public async Task CommitTransactionAsync(IDbContextTransaction transaction) { if (transaction == null) { throw new ArgumentNullException(nameof(transaction)); } if (transaction != _currentTransaction) { throw new InvalidOperationException($"Transaction {transaction.TransactionId} is not current"); } try { await SaveChangesAsync(); transaction.Commit(); } catch { RollbackTransaction(); throw; } finally { if (_currentTransaction != null) { _currentTransaction.Dispose(); _currentTransaction = null; } } }
public async Task CommitTransactionAsync(DbTransaction transaction) { Guard.Against.Null(transaction, nameof(transaction)); if (transaction != CurrentTransaction) { throw new InvalidOperationException($"Transaction {CurrentTransactionId} is not current"); } try { await SaveChangesAsync(); transaction.Commit(); } catch { RollbackTransaction(); throw; } finally { if (currentTransaction != null) { currentTransaction.Dispose(); currentTransaction = null; } } }
public void CommitTransaction() { if (_transaction != null) { _transaction.Commit(); _transaction.Dispose(); } }
public void Commit() { transaction.Commit(); transaction.Dispose(); transaction = null; }
/// <summary> /// /// </summary> public void Rollback() { if (transaction != null) { transaction.Rollback(); transaction.Dispose(); } }
/// <inheritdoc cref="Repository{TEntity}.CommitTransaction"/> public override void CommitTransaction() { if (_dbTransaction != null) { _dbTransaction.Commit(); _dbTransaction.Dispose(); } _dbTransaction = null; }
public void Commit() { try { SaveChanges(); _transaction.Commit(); } finally { _transaction.Dispose(); } }
public void CommitTransaction() { if (transactionScope != null) { transactionScope.Commit(); transactionScope.Dispose(); transactionScope = null; } }
public void Commit() { try { databaseContext.SaveChanges(); transaction.Commit(); } finally { transaction.Dispose(); } }
public void Commit() { if (_Transaction != null) { _Transaction.Commit(); _Transaction.Dispose(); _Transaction = null; } }
public Task <int> SaveAsync() { var count = _dbContext.SaveChangesAsync(); _transaction?.Commit(); _transaction?.Dispose(); _transaction = null; return(count); }
public void CommitTransaction() { _context.SaveChanges(); if (_transaction != null) { _transaction.Commit(); _transaction.Dispose(); _transaction = null; } }
public void CommitTransaction() { if (_transaction == null) { throw new Exception("Not in transaction"); } _transaction.Commit(); _transaction.Dispose(); _transaction = null; }
public void Dispose() { _context.Dispose(); if (_transaction != null) { _transaction.Dispose(); } GC.SuppressFinalize(_context); GC.SuppressFinalize(this); GC.Collect(); }
public void Commit() { try { _transaction.Commit(); } finally { _transaction.Dispose(); } }
public void CommitTransaction() { if (Transaction == null) { throw new Exception("Cannot commit a transaction which has not been started"); } Transaction.Commit(); Transaction.Dispose(); Transaction = null; }
public void DisposeTransaction() { if (TransactionActive) { _transactionContext.Dispose(); _context.Dispose(); } _transactionContext = null; _context = null; }
//public void BeginTransaction(IsolationLevel level) //{ // _transaction = _context.Database.BeginTransaction(level); //} public void CommitTransaction() { if (_transaction == null) { return; } _transaction.Commit(); _transaction.Dispose(); _transaction = null; }
public void CommitTransaction() { try { _dbContext.SaveChanges(); _transaction.Commit(); } finally { _transaction.Dispose(); } }
public async Task SaveAllChangesAsync() { try { await SaveChangesAsync(); transaction.Commit(); } finally { transaction.Dispose(); } }
public async Task Commit() { try { await _Context.SaveChangesAsync(); _transaction.Commit(); } finally { _transaction.Dispose(); } }
public async Task CommitAsync(CancellationToken cancellationToken = default) { try { await Context.SaveChangesAsync(cancellationToken); _transaction.Commit(); } finally { _transaction.Dispose(); } }
public int Commit() { try { var saveChanges = SaveChanges(); _transaction.Commit(); return(saveChanges); } finally { _transaction.Dispose(); } }
public void CommitTransaction() { _dbContext.SaveChanges(); if (_transaction == null) { return; } _transaction.Commit(); _transaction.Dispose(); _transaction = null; }