public async Task <bool> Commit(bool state = true) { if (!state) { await dbContextTransaction.RollbackAsync(); return(state); } bool commitState; try { await SaveChangesAsync(); commitState = true; } catch { commitState = false; } if (commitState) { await dbContextTransaction.CommitAsync(); } else { await dbContextTransaction.RollbackAsync(); } return(commitState); }
public async Task CommitAsync(CancellationToken cancellationToken = default) { try { await _transaction.CommitAsync(cancellationToken); } catch { await _transaction.RollbackAsync(cancellationToken); } }
public async Task RollbackTransactionAsync() { if (HasActiveTransaction) { try { await _currentTransaction.RollbackAsync(); } finally { _currentTransaction.Dispose(); _currentTransaction = null; } } }
public async ValueTask DisposeAsync() { if (!_commited) { await _transaction.RollbackAsync(); } }
async Task IUow.Rollback() { if (_transaction != null) { await _transaction.RollbackAsync(_token); } }
public async Task RollbackTransactionAsync() { if (_transaction == null) throw new InvalidOperationException($"You did not start a Transaction by calling \"{nameof(StartTransactionAsync)}\" method."); await _transaction.RollbackAsync(); }
public async Task RollbackTransactionAsync() { await Transaction.RollbackAsync(); Transaction?.Dispose(); Transaction = null; }
public void Rollback() { if (_dbContextTransaction != null) { _dbContextTransaction.RollbackAsync().Wait(); } }
public async Task <IActionResult> Create(Employee employee) { if (ModelState.IsValid) { IDbContextTransaction transaction = await _repository.BeginTransactionAsync(IsolationLevel.ReadCommitted); try { employee.DepartmentId = 1; object[] primaryKeys = await _repository.InsertAsync(employee); long employeeId = (long)primaryKeys[0]; EmployeeHistory employeeHistory = new EmployeeHistory() { EmployeeId = employeeId, DepartmentId = employee.DepartmentId, EmployeeName = employee.EmployeeName }; await _repository.InsertAsync(employeeHistory); await transaction.CommitAsync(); } catch (Exception) { await transaction.RollbackAsync(); } return(RedirectToAction(nameof(Index))); } return(View(employee)); }
public async Task <ActionResult <Cake> > Put(Cake cake) { using (IDbContextTransaction dbContextTransaction = context.Database.BeginTransaction()) { try { try { cake.PreparationDate = DateTime.Now; context.Entry(cake).State = EntityState.Modified; await context.SaveChangesAsync(); await dbContextTransaction.CommitAsync(); return(Ok(cake)); } catch (Exception ex) { await dbContextTransaction.RollbackAsync(); return(BadRequest(new RetornoRequisicao { Mensagem = ex.Message, Sucesso = false })); } } catch (Exception ex) { var retorno = new RetornoRequisicao() { Mensagem = ex.Message, Sucesso = false }; return(BadRequest(retorno)); } } }
public async Task <Config> Handle(UpdateConfigCommand request, CancellationToken cancellationToken) { await using IDbContextTransaction transaction = _configContext.Database.BeginTransaction(); try { (Config config, ConfigElement root, ConfigElement[] all)configSource = await _configService.GetConfigElement( () => _configService.GetConfig(request, EnvironmentRole.Editor, cancellationToken), cancellationToken); Config config = new Config(request.ConfigCode, configSource.config.Environment, request.VersionFrom); ObjectConfigReader reader = new ObjectConfigReader(config); ConfigElement configElement = await reader.Parse(request.Data); Compare(configSource.root, configElement); await _configContext.SaveChangesAsync(cancellationToken); await _cacheService.UpdateJsonConfig(configSource.config.ConfigId, request.Data, cancellationToken); await transaction.CommitAsync(cancellationToken); return(configSource.config); } catch (Exception ex) { await transaction.RollbackAsync(cancellationToken); _logger.LogError(ex, "{request} data:{Data}", request, request.Data); throw; } }
public async Task RollbackAsync() { if (_isTransactionStarted && _dbContextTransaction != null) { await _dbContextTransaction?.RollbackAsync(); } }
/// <summary> /// 事务执行 - Async /// </summary> /// <param name="dbContext"></param> /// <param name="func"></param> /// <returns></returns> public static async Task ExecuteTransactionAsync <TDbContext>(this TDbContext context, Func <TDbContext, IDbConnection, IDbTransaction, Task> func, IsolationLevel isolationLevel = IsolationLevel.ReadCommitted) where TDbContext : DbContext { if (func == null) { throw new ArgumentNullException(nameof(func)); } IDbContextTransaction tran = await context.Database.BeginTransactionAsync(isolationLevel); try { DbConnection connection = context.Database.GetDbConnection(); DbTransaction transaction = tran.GetDbTransaction(); await func(context, connection, transaction); await tran.CommitAsync(); } catch (Exception ex) { await tran?.RollbackAsync(); throw; } finally { tran?.Dispose(); } }
public async Task RollbackTransactionAsync() { if (_transaction != null) { await _transaction.RollbackAsync(); } }
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; } } }
public async Task RoleBack() { await _dbContextTransaction.RollbackAsync(); _dbContextTransaction.Dispose(); _dbContextTransaction = null; }
public async Task RollbackAsync(CancellationToken cancellationToken = default) { if (!_existingTransaction) { await _transaction.RollbackAsync(); } }
public async Task <bool> CommitAsync() { using (IDbContextTransaction transaction = _context.Database.BeginTransaction()) { try { var changes = await _context.SaveChangesAsync(); await transaction.CommitAsync(); return(true); } catch (Exception ex) { Console.WriteLine(ex.Message); await transaction.RollbackAsync(); return(false); } finally { //usar em banco de dados relacional e que nao seja em memoria //_contextEntity.Database.GetDbConnection().Close(); } } }
public async Task Rollback() { if (transaction != null) { await transaction.RollbackAsync(); } }
public async override Task Invoke(AspectContext context, AspectDelegate next) { DbContext dbContext = context.ServiceProvider.GetService(_dbContextType) as DbContext; if (dbContext.Database.CurrentTransaction == null) { using IDbContextTransaction transaction = await dbContext.Database.BeginTransactionAsync(); try { await next(context); await transaction.CommitAsync(); //dbContext.Database.CommitTransaction(); } catch (Exception ex) { await transaction.RollbackAsync(); //dbContext.Database.RollbackTransaction(); throw ex; } } else { await next(context); } }
// Map model to order // Set date to order // Calculate total cost and OrderProduct prices // Insert order // Set orderId to orderProducts // Insert orderProducts public async Task <DataResult <int> > CreateOrder(OrderCreationalModel orderCreationalModel) { using (IDbContextTransaction transaction = await _orderRepository.BeginTransactionAsync()) { try { Order order = _orderMapper.MapBackToEntity(orderCreationalModel); order.OrderDate = DateTime.UtcNow; order = await _orderRepository.AddAsync(order); await _orderRepository.SaveAsync(); foreach (OrderProductModel orderProductModel in orderCreationalModel.OrderProductModels) { Result orderProductAddResult = await AddOrderProductAsync(order, orderProductModel); if (orderProductAddResult.ResponseMessageType == ResponseMessageType.Error) { await transaction.RollbackAsync(); return(new DataResult <int> { ResponseMessageType = ResponseMessageType.Error }); } } _orderRepository.Update(order); await _orderRepository.SaveAsync(); await transaction.CommitAsync(); return(new DataResult <int> { Data = order.Id, ResponseMessageType = ResponseMessageType.Success }); } catch (Exception) { await transaction.RollbackAsync(); throw; } } }
public async Task RollbackAsync(CancellationToken cancellationToken = default(CancellationToken)) { CheckNotNull(_dbTransaction); await _dbTransaction.RollbackAsync(cancellationToken); _unitOfWorkStatus.IsStartingUow = false; }
public async ValueTask DisposeAsync() { await _transaction.RollbackAsync().ConfigureAwait(false); await _transaction.DisposeAsync().ConfigureAwait(false); _scope.Dispose(); }
public async Task RollbackAsync(CancellationToken cancellationToken = default) { await _transaction.RollbackAsync(); await _transaction.DisposeAsync(); _transaction = null; }
public async Task RollbackTransactionAsync() { await _dbTransaction.RollbackAsync(); await _dbTransaction.DisposeAsync(); _dbTransaction = null; }
public async Task RollbackAsync() { ValidateTransaction(); await transaction.RollbackAsync(); await DisposeTransactionAsync(); }
public async Task RollbackAsync() { if (_transaction != null) { await _transaction.RollbackAsync(); await DisposableAsync(); } }
public async Task <IResult> RollbackTransactionAsync(CancellationToken cancellationToken = default) { if (_transaction != null) { await _transaction.RollbackAsync(cancellationToken).ConfigureAwait(false); } return(Result.Ok()); }
/// <summary> /// Cancelar a transação /// </summary> /// <param name="cancellationToken">Token de cancelamento</param> public async Task RollBackAsync(CancellationToken cancellationToken = default) { await _transaction.RollbackAsync(cancellationToken) .ContinueWith((tsk) => { TransactionStarted = false; }); }
public Task RollbackAsync(CancellationToken token = default) { if (TransactionId == Guid.Empty) { return(Task.CompletedTask); } return(_transaction.RollbackAsync(token)); }