public override DbTransaction TransactionStarted(DbConnection connection, TransactionEndEventData eventData, DbTransaction result) { //Debug.WriteLine(Environment.StackTrace); _logger.LogInformation("TransactionStarted: {0}", eventData.TransactionId); return(base.TransactionStarted(connection, eventData, result)); }
public DbTransaction TransactionStarted(DbConnection connection, TransactionEndEventData eventData, DbTransaction result) { TrackEvent(nameof(TransactionStarted), connection, eventData.ConnectionId); return(result); }
public override void TransactionCommitted(DbTransaction transaction, TransactionEndEventData eventData) { Debug.WriteLine(Environment.StackTrace); _logger.LogInformation("TransactionCommitted: {0}", eventData.TransactionId); base.TransactionCommitted(transaction, eventData); }
public ValueTask <DbTransaction> TransactionStartedAsync(DbConnection connection, TransactionEndEventData eventData, DbTransaction result, CancellationToken cancellationToken = new CancellationToken()) { TrackEvent(nameof(TransactionStartedAsync), connection, eventData.ConnectionId); return(ValueTask.FromResult(result)); }
public void TransactionCommitted( DbTransaction transaction, TransactionEndEventData eventData) { for (var i = 0; i < _interceptors.Length; i++) { _interceptors[i].TransactionCommitted(transaction, eventData); } }
public void TransactionRolledBack( DbTransaction transaction, TransactionEndEventData eventData) { for (var i = 0; i < _interceptors.Length; i++) { _interceptors[i].TransactionRolledBack(transaction, eventData); } }
public override DbTransaction TransactionStarted( DbConnection connection, TransactionEndEventData eventData, DbTransaction result) { result = base.TransactionStarted(connection, eventData, result); return(new WrappedDbTransaction(result)); }
public async Task TransactionRolledBackAsync( DbTransaction transaction, TransactionEndEventData eventData, CancellationToken cancellationToken = default) { for (var i = 0; i < _interceptors.Length; i++) { await _interceptors[i].TransactionRolledBackAsync(transaction, eventData, cancellationToken); } }
public override async Task <DbTransaction> TransactionStartedAsync( DbConnection connection, TransactionEndEventData eventData, DbTransaction result, CancellationToken cancellationToken = default) { result = await base.TransactionStartedAsync(connection, eventData, result, cancellationToken); return(new WrappedDbTransaction(result)); }
public async Task TransactionCommittedAsync( DbTransaction transaction, TransactionEndEventData eventData, CancellationToken cancellationToken = default) { for (var i = 0; i < _interceptors.Length; i++) { await _interceptors[i].TransactionCommittedAsync(transaction, eventData, cancellationToken) .ConfigureAwait(false); } }
public DbTransaction TransactionStarted( DbConnection connection, TransactionEndEventData eventData, DbTransaction result) { for (var i = 0; i < _interceptors.Length; i++) { result = _interceptors[i].TransactionStarted(connection, eventData, result); } return(result); }
public async Task <DbTransaction> TransactionStartedAsync( DbConnection connection, TransactionEndEventData eventData, DbTransaction result, CancellationToken cancellationToken = default) { for (var i = 0; i < _interceptors.Length; i++) { result = await _interceptors[i].TransactionStartedAsync(connection, eventData, result, cancellationToken); } return(result); }
public override async void TransactionCommitted( DbTransaction transaction, TransactionEndEventData eventData) { try { await PublishEvents(eventData); } catch (Exception ex) { _logger.LogError(ex, "Error in EventTransactionInterceptor"); } finally { base.TransactionCommitted(transaction, eventData); } }
public override async Task TransactionCommittedAsync( DbTransaction transaction, TransactionEndEventData eventData, CancellationToken cancellationToken = default) { try { await PublishEvents(eventData); } catch (Exception ex) { _logger.LogError(ex, "Error in EventTransactionInterceptor"); } finally { await base.TransactionCommittedAsync(transaction, eventData, cancellationToken); } }
public override async Task <DbTransaction> TransactionStartedAsync(DbConnection connection, TransactionEndEventData eventData, DbTransaction result, CancellationToken cancellationToken = new CancellationToken()) { return(await base.TransactionStartedAsync(connection, eventData, result, cancellationToken)); }
public override async Task TransactionRolledBackAsync(DbTransaction transaction, TransactionEndEventData eventData, CancellationToken cancellationToken = new CancellationToken()) { await base.TransactionRolledBackAsync(transaction, eventData, cancellationToken); }
private async Task PublishEvents(TransactionEndEventData eventData) { var entries = GetEntries(eventData.Context as SteamfitterContext); using (var scope = _serviceProvider.CreateScope()) { var events = new List <INotification>(); var mediator = scope.ServiceProvider.GetRequiredService <IMediator>(); foreach (var entry in entries) { var entityType = entry.Entity.GetType(); Type eventType = null; string[] modifiedProperties = null; switch (entry.State) { case EntityState.Added: eventType = typeof(EntityCreated <>).MakeGenericType(entityType); // Make sure properties generated by the db are set var generatedProps = entry.Properties .Where(x => x.Metadata.ValueGenerated == Microsoft.EntityFrameworkCore.Metadata.ValueGenerated.OnAdd) .ToList(); foreach (var prop in generatedProps) { entityType.GetProperty(prop.Metadata.Name).SetValue(entry.Entity, prop.CurrentValue); } break; case EntityState.Modified: eventType = typeof(EntityUpdated <>).MakeGenericType(entityType); modifiedProperties = entry.Properties .Where(x => x.IsModified) .Select(x => x.Metadata.Name) .ToArray(); break; case EntityState.Deleted: eventType = typeof(EntityDeleted <>).MakeGenericType(entityType); break; } if (eventType != null) { INotification evt; if (modifiedProperties != null) { evt = Activator.CreateInstance(eventType, new[] { entry.Entity, modifiedProperties }) as INotification; } else { evt = Activator.CreateInstance(eventType, new[] { entry.Entity }) as INotification; } if (evt != null) { events.Add(evt); } } } foreach (var evt in events) { await mediator.Publish(evt); } } }
public override Task TransactionCommittedAsync(DbTransaction transaction, TransactionEndEventData eventData, CancellationToken cancellationToken = default) { return(Task.CompletedTask); }
public void TransactionCommitted(DbTransaction transaction, TransactionEndEventData eventData) { TrackEvent(nameof(TransactionCommitted), transaction.Connection, eventData.ConnectionId); }
/// <summary> /// Called immediately after EF calls <see cref="DbConnection.BeginTransaction(IsolationLevel)" />. /// </summary> /// <remarks> /// This method is still called if an interceptor suppressed creation in <see cref="IDbTransactionInterceptor.TransactionStarting" />. /// In this case, <paramref name="result" /> is the result returned by <see cref="IDbTransactionInterceptor.TransactionStarting" />. /// </remarks> /// <param name="connection">The connection.</param> /// <param name="eventData">Contextual information about connection and transaction.</param> /// <param name="result"> /// The result of the call to <see cref="DbConnection.BeginTransaction(IsolationLevel)" />. /// This value is typically used as the return value for the implementation of this method. /// </param> /// <returns> /// The result that EF will use. /// A normal implementation of this method for any interceptor that is not attempting to change the result /// is to return the <paramref name="result" /> value passed in. /// </returns> public virtual DbTransaction TransactionStarted( DbConnection connection, TransactionEndEventData eventData, DbTransaction result) => result;
public override void TransactionRolledBack(DbTransaction transaction, TransactionEndEventData eventData) { base.TransactionRolledBack(transaction, eventData); }
public override void TransactionCommitted(DbTransaction transaction, TransactionEndEventData eventData) { base.TransactionCommitted(transaction, eventData); }
public void TransactionRolledBack(DbTransaction transaction, TransactionEndEventData eventData) { TrackEvent(nameof(TransactionRolledBack), transaction.Connection, eventData.ConnectionId); }
public Task TransactionRolledBackAsync(DbTransaction transaction, TransactionEndEventData eventData, CancellationToken cancellationToken = new CancellationToken()) { TrackEvent(nameof(TransactionRolledBackAsync), transaction.Connection, eventData.ConnectionId); return(Task.CompletedTask); }