public override void Commit() { base.Commit(); _clientSessionHandle.CommitTransaction(); _clientSessionHandle.Dispose(); _clientSessionHandle = null; }
public void Commit() { if (_transactionCounter == 1) { try { Transaction.Commit(); _mongoSession.CommitTransaction(); } catch { Transaction.Rollback(); _mongoSession.AbortTransaction(); throw; } finally { _connection.Close(); Transaction.Dispose(); _mongoSession.Dispose(); } } _transactionCounter--; }
public async void CommitAsync() { if (_session == null) { throw new Exception("Session has been gone somehow!"); } await _session.CommitTransactionAsync(); _session.Dispose(); }
public void Commit() { try { _transactionSession.CommitTransaction(); } finally { _transactionSession.Dispose(); } }
public void Dispose() { if (_clientSessionHandle != null) { _clientSessionHandle.Dispose(); } }
public void Dispose() { if (_session != null) { _session.Dispose(); } }
public void EndSession(IClientSessionHandle session) { if (!session.IsInTransaction) { session.Dispose(); } }
protected virtual void Dispose(bool disposing) { if (disposing) { session?.Dispose(); } }
public void Dispose() { if (!_disposed) { _transactionSession?.Dispose(); _disposed = true; } }
public override void Dispose() { if (_session?.IsInTransaction == true) { _session.AbortTransaction(); } _session?.Dispose(); base.Dispose(); }
public void Dispose() { _session.Dispose(); if (!_isCompleted) { _onCompleted(false); } }
protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { _transaction?.Dispose(); } disposedValue = true; } }
public virtual void Dispose() { transaction = transactionStack.Pop(); transaction.Dispose(); if (transactionStack.Count > 0) { transaction = transactionStack.First(); return; } }
public async Task ApplyChangesAsync(CancellationToken token = default) { if (_operations.Count > 0) { IClientSessionHandle session = null; if (_connection.UseTransactions) { session = _connection.StartSession(); session.StartTransaction(); } try { while (_operations.Count > 0) { var item = _operations.Dequeue(); await item.ProcessAsync(session, token); } if (session != null) { await session.CommitTransactionAsync(token); session.Dispose(); } _operations.Clear(); } catch { if (session != null) { await session.AbortTransactionAsync(token); session.Dispose(); } throw; } } }
protected override void Dispose(bool disposing) { try { session?.Dispose(); } catch { //No need to throw on disposal } base.Dispose(disposing); }
public void Dispose() { if (null != session) { if (session.IsInTransaction) { session.AbortTransaction(); } session.Dispose(); } }
protected override void Dispose(bool disposing) { if (_disposed) { return; } _mongoClient = null; _clientSessionHandle?.Dispose(); _clientSessionHandle = null; base.Dispose(disposing); }
protected virtual void Dispose(bool disposing) { if (_disposed) { return; } if (disposing && _dispose) { _Session.Dispose(); } _disposed = true; }
private static async Task CommitOrAbortTx(IClientSessionHandle session, AppendResult result) { if (session != null) { if (result.HadWrongVersion || string.IsNullOrWhiteSpace(result.CommitId) || result.CurrentVersion <= 0) { await session.AbortTransactionAsync(); } else { await session.CommitTransactionAsync(); } session.Dispose(); } }
public async Task CommitAsync() { _mongoDbSession = await _eventStoreContext.Client.StartSessionAsync(); _mongoDbSession.StartTransaction(); var insertToESTasks = new List <Task>(); foreach (var eventTransaction in _transactions) { insertToESTasks.Add(InsertEventsToESAsync(eventTransaction.Value, eventTransaction.Key)); } await Task.WhenAll(insertToESTasks); await _mongoDbSession.CommitTransactionAsync(); _mongoDbSession.Dispose(); }
private async Task ExecuteWithClientSession(IMongoCollection <T> collection, IClientSessionHandle session, Func <IClientSessionHandle, Task> action) { var closeSession = false; if (session == null) { session = collection.Database.Client.StartSession(); closeSession = true; } try { await action(session); } finally { if (closeSession) { session.Dispose(); } } }
public async Task <int> SaveChangesAsync() { int count = _commands.Count; CancellationToken token = new CancellationToken(); using (Session = await MongoClient.StartSessionAsync(options: null, cancellationToken: token)) { Session.StartTransaction(); var commandTasks = _commands.Select(c => c()); await Task.WhenAll(commandTasks); //await Session.AbortTransactionAsync(token); await Session.CommitTransactionAsync(); _commands.Clear(); Session.Dispose(); Session = null; } return(count); }
public void Dispose() { _clientSessionHandle.Dispose(); }
public void Dispose() { _session?.Dispose(); }
public void Dispose() { mongoSession.Dispose(); }
public void Execute() { _session.Dispose(); }
public async Task HandleAsync(string messageId, Func <Task> handler) { if (!Enabled) { _logger.LogWarning("Outbox is disabled, incoming messages won't be processed."); return; } if (string.IsNullOrWhiteSpace(messageId)) { throw new ArgumentException("Message id to be processed cannot be empty.", nameof(messageId)); } _logger.LogTrace($"Received a message with id: '{messageId}' to be processed."); if (await _inboxRepository.ExistsAsync(m => m.Id == messageId)) { _logger.LogTrace($"Message with id: '{messageId}' was already processed."); return; } IClientSessionHandle session = null; if (_transactionsEnabled) { session = await _sessionFactory.CreateAsync(); session.StartTransaction(); } try { _logger.LogTrace($"Processing a message with id: '{messageId}'..."); await handler(); await _inboxRepository.AddAsync(new InboxMessage { Id = messageId, ProcessedAt = DateTime.UtcNow }); if (session is not null) { await session.CommitTransactionAsync(); } _logger.LogTrace($"Processed a message with id: '{messageId}'."); } catch (Exception ex) { _logger.LogError(ex, $"There was an error when processing a message with id: '{messageId}'."); if (session is not null) { await session.AbortTransactionAsync(); } throw; } finally { session?.Dispose(); } }
public void Dispose() => _session.Dispose();
public void Dispose() { session.Dispose(); }
public void Dispose() { _session?.Dispose(); GC.SuppressFinalize(this); }