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