public void Rollback() { try { _tx?.Rollback(); } finally { if (_tx != null) { _tx.Dispose(); _tx = null; } } }
public void RollbackTransaction() { try { _currentTransaction?.Rollback(); } finally { if (_currentTransaction != null) { _currentTransaction.Dispose(); _currentTransaction = null; } } }
public void RollbackTransaction() { try { _dbContextTransaction?.Rollback(); } finally { if (_dbContextTransaction != null) { _dbContextTransaction.Dispose(); _dbContextTransaction = null; } } }
public void RollbackTransaction() { try { transaction?.Rollback(); } finally { if (transaction != null) { transaction.Dispose(); transaction = null; } } }
private void RollBackTransaction(IDbContextTransaction transaction) { try { transaction?.Rollback(); } catch (Exception e) { logger.LogDebug(CoreMessages.RollbackFailed + Environment.NewLine + e.Message); } try { transaction?.Dispose(); } catch {} }
public void RollbackTransaction() { try { _currentTransaction?.Rollback(); _logger.LogWarning($"Rollback transaction id: {_currentTransaction.TransactionId}."); } finally { if (_currentTransaction != null) { _currentTransaction.Dispose(); _currentTransaction = null; } } }
/// <summary> /// 回滚所有事务 /// </summary> public virtual void Rollback() { dbContextTransaction?.Rollback(); if (dbContext.IsRelationalTransaction()) { CleanChanges(dbContext); if (dbContext.Database.CurrentTransaction != null) { dbContext.Database.CurrentTransaction.Rollback(); dbContext.Database.CurrentTransaction.Dispose(); } } dbContext.Database.RollbackTransaction(); HasCommitted = true; }
public Task RollbackTransactionAsync() { try { _currentTransaction?.Rollback(); } finally { if (_currentTransaction is not null) { _currentTransaction.Dispose(); _currentTransaction = null; } } return(Task.CompletedTask); }
public int Execute( IEnumerable <ModificationCommandBatch> commandBatches, IRelationalConnection connection) { var registrosAfetados = 0; connection.Open(); IDbContextTransaction startedTransaction = null; try { if (connection.CurrentTransaction == null) { startedTransaction = connection.BeginTransaction(); } foreach (var commandbatch in commandBatches) { commandbatch.Execute(connection); registrosAfetados += commandbatch.ModificationCommands.Count; } startedTransaction?.Commit(); startedTransaction?.Dispose(); } catch (Exception ex) { ex.Message.ToString(); try { startedTransaction?.Rollback(); startedTransaction?.Dispose(); } catch { // if the connection was lost, rollback command will fail. prefer to throw original exception in that case } throw; } finally { connection.Close(); } return(registrosAfetados); }
public async Task RollbackAsync(CancellationToken cancellationToken) { if (_transaction != null) { await _transactionSempahore.WaitAsync(cancellationToken); try { _transaction?.Rollback(); _transaction = null; } finally { _transactionSempahore.Release(); } } }
public int Execute(IEnumerable <ModificationCommandBatch> commandBatches, IRelationalConnection connection) { var recordAffecteds = 0; if (connection?.DbConnection?.State != System.Data.ConnectionState.Open) { connection.Open(); } IDbContextTransaction currentTransaction = null; try { if (connection.CurrentTransaction == null) { currentTransaction = connection.BeginTransaction(); } foreach (var commandbatch in commandBatches) { commandbatch.Execute(connection); recordAffecteds += commandbatch.ModificationCommands.Count; } currentTransaction?.Commit(); currentTransaction?.Dispose(); } catch (Exception ex) { try { currentTransaction?.Rollback(); currentTransaction?.Dispose(); } catch { // } throw ex; } finally { connection?.Close(); } return(recordAffecteds); }
public void Commit(IDbContextTransaction?transaction) { try { Context.SaveChanges(); transaction?.Commit(); } catch (ValidationException ex) { var errors = FormatError(ex); throw new Exception(errors, ex); } catch { transaction?.Rollback(); throw; } }
public void Commit() { try { if (_transaction == null) { DbContext.SaveChanges(); } else { _transaction.Commit(); } } catch (Exception ex) { _transaction?.Rollback(); } }
///<summary> /// 回滚事物 /// </summary> public void RollbackTransaction() { try { _currentTransation?.Rollback(); } catch (Exception ex) { throw ex; } finally { if (_currentTransation != null) { _currentTransation.Dispose(); _currentTransation = null; } } }
private int Commit() { var result = 0; try { result = Context.SaveChanges(); Transaction?.Commit(); return(result); } catch (Exception e) { result = -1; Transaction?.Rollback(); Log.Error("Context Transaction Error"); Log.Error(e.Message); } return(result); }
public void Rollback() { if (_context == null) { throw new ArgumentNullException(nameof(_context)); } try { _dbContextTransaction?.Rollback(); } catch { if (_dbContextTransaction != null) { _dbContextTransaction.Dispose(); _dbContextTransaction = null; } } }
private static void ExecuteSql(DbContext context, string sqlName, IDbContextTransaction t, string[] sqlParts) { foreach (var part in sqlParts) { try { if (string.IsNullOrWhiteSpace(part)) { continue; } context.Database.ExecuteSqlRaw(part); } catch (Exception ex) { t?.Rollback(); throw new Exception(sqlName + Environment.NewLine + ex.Message, ex); } } }
public bool UpdateLocation(LocationViewModel obj) { bool result; IDbContextTransaction transaction = _context.Database.BeginTransaction(); var location = _location.GetLocationByID(obj.ID); if (location != null) { try { obj.SubCategory = _generatecode.SubCategoryLocation(obj.LocationTypeCD, obj.Floor); obj.Code = _generatecode.GenerateCode(obj.CompanyCode, obj.ApplicationCode, obj.MainCategory, obj.SubCategory, location.No); if (location.Code != obj.Code) { location.Code = obj.Code; } location.Description = obj.Description; location.Name = obj.Name; location.Floor = obj.Floor; location.LocationTypeCD = obj.LocationTypeCD; location.StatusCD = obj.StatusCD; location.UpdatedBy = obj.UpdatedBy; location.UpdatedDate = DateTime.Now.Date.ToString("ddMMyyyy"); _context.Entry(location).State = EntityState.Modified; _context.SaveChanges(); transaction.Commit(); result = true; } catch (Exception ex) { transaction.Rollback(); result = false; } } else { result = false; } return(result); }
public bool CreateLocation(LocationViewModel obj) { bool result; IDbContextTransaction transaction = _context.Database.BeginTransaction(); if (obj != null) { try { obj.Location.No = _location.GetLastNumberLocation(); obj.SubCategory = _generatecode.SubCategoryLocation(Convert.ToInt16(obj.Location.LocationTypeCD), obj.Location.Floor); obj.Number = _generatecode.Number(obj.Location.No); obj.Location.Code = _generatecode.GenerateCode(obj.CompanyCode, obj.ApplicationCode, obj.MainCategory, obj.SubCategory, obj.Number); Location location = new Location(); location.Code = obj.Location.Code; location.Description = obj.Location.Description; location.No = obj.Number; location.Name = obj.Location.Name; location.Floor = obj.Location.Floor; location.LocationTypeCD = Convert.ToInt16(obj.Location.LocationTypeCD); location.StatusCD = obj.Location.StatusCD; location.CreatedBy = obj.CreatedBy; location.CreatedDate = obj.CreatedDate;//DateTime.Now; _context.Location.Add(location); _context.SaveChanges(); transaction.Commit(); result = true; } catch (Exception ex) { transaction.Rollback(); result = false; } } else { result = false; } return(result); }
private void usageCompleted(DatabaseWriteUsage usage) { int usages = Interlocked.Decrement(ref currentWriteUsages); try { currentWriteDidWrite |= usage.PerformedWrite; currentWriteDidError |= usage.Errors.Any(); if (usages == 0) { if (currentWriteDidError) { rollbacks.Value++; currentWriteTransaction?.Rollback(); } else { commits.Value++; currentWriteTransaction?.Commit(); } if (currentWriteDidWrite || currentWriteDidError) { // explicitly dispose to ensure any outstanding flushes happen as soon as possible (and underlying resources are purged). usage.Context.Dispose(); // once all writes are complete, we want to refresh thread-specific contexts to make sure they don't have stale local caches. recycleThreadContexts(); } currentWriteTransaction = null; currentWriteDidWrite = false; currentWriteDidError = false; } } finally { Monitor.Exit(writeLock); } }
public void Dispose() { if (_disposed) { return; } if (_shouldRollback) { _transaction?.Rollback(); } else { _transaction.Commit(); } _transaction?.Dispose(); _context.Dispose(); _disposed = true; }
public void ProcessTransaction(Action action) { if (_transaction != null) { throw new InvalidOperationException("Transaction in process"); } try { using (_transaction = _context.Database.BeginTransaction()) { action(); _transaction.Commit(); } } catch (Exception ex) { _transaction.Rollback(); throw; } }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="disposing"> /// <c>true</c> to release both managed and unmanaged resources; <c>false</c> to release /// only unmanaged resources. /// </param> protected virtual void Dispose(bool disposing) { if (_disposed) { return; } if (_rollbackOnDispose) { _log.Warn("Rolling back Unit Of Work Transaction..."); _transaction.Rollback(); } else { SaveChanges(); _transaction.Commit(); } _transaction.Dispose(); _disposed = true; }
/// <summary> /// Rolls back the transaction. /// </summary> /// <remarks> /// This is internal because it is only intended to be called by a ChildTransactionScope /// </remarks> internal void Rollback() { switch (_transactionState) { case TransactionState.Open: _dbContextTransaction.Rollback(); _transactionState = TransactionState.RolledBack; break; case TransactionState.RolledBack: // The transaction has already been rolled back break; case TransactionState.Closed: case TransactionState.Commited: throw new InvalidOperationException("Cannot rollback the transaction because the transaction is already " + _transactionState.ToString().ToLower()); default: throw new NotImplementedException("Unrecognised TransactionState: " + _transactionState); } }
public int SaveChanges() { int resultOfSaveChanges = -1; try { resultOfSaveChanges = _context.SaveChanges(); _transaction.Commit(); } catch (Exception ex) { _transaction.Rollback(); resultOfSaveChanges = _context.SaveChanges(); //Hatalar Loglanabilir } finally { _transaction.Dispose(); _transaction = _context.Database.BeginTransaction(); } return(resultOfSaveChanges); }
public async Task ExecuteScopeAsync(Func <IServiceProvider, Task> action) { IDbContextTransaction transaction = null; using (var scope = ScopeFactory.CreateScope()) { var dbContext = scope.ServiceProvider.GetService <CatalogContext>(); try { transaction = dbContext.Database.BeginTransaction(); await action(scope.ServiceProvider); } catch (Exception) { transaction?.Rollback(); throw; } transaction?.Commit(); } }
public void Dispose() { try { if (Invoke == null) { throw new Exception("Please set Transaction.Invoke!"); } Invoke?.Invoke(); _transation.Commit(); } catch { _transation.Rollback(); throw; } finally { _transation.Dispose(); } }
public void Rollback() { _transaction.Rollback(); foreach (var entry in _context.ChangeTracker.Entries()) { switch (entry.State) { case EntityState.Modified: entry.State = EntityState.Unchanged; break; case EntityState.Added: entry.State = EntityState.Detached; break; case EntityState.Deleted: entry.State = EntityState.Unchanged; break; } } }
public User Add(UserIdentity userIdentity, User user) { using IDbContextTransaction transaction = _db.Database.BeginTransaction(); try { UserIdentity addedIdentity = _db.UserIdentities.Add(userIdentity).Entity; _db.SaveChanges(); user.UserId = addedIdentity.UserId; user.UserIdentity = addedIdentity; User addedUser = _db.Users.Add(user).Entity; _db.SaveChanges(); transaction.Commit(); return(addedUser); } catch (Exception) { transaction.Rollback(); throw; } }
public async Task <ActionResult <Questions> > PostQuestions(Questions questions) { // context.Database.Log = Console.Write; // maintaing transaction while inserting data using (IDbContextTransaction transaction = _context.Database.BeginTransaction()) { try { _context.Questions.Add(questions); await _context.SaveChangesAsync(); transaction.Commit(); } catch (System.Exception ex) { transaction.Rollback(); } } return(CreatedAtAction("GetQuestions", new { id = questions.QuestionID }, questions)); }