public static Int32 SaveChangesWithTriggers(this DbContext dbContext, Func <Int32> baseSaveChanges, IServiceProvider serviceProvider)
{
#endif
if (dbContext == null)
{
throw new ArgumentNullException(nameof(dbContext));
}
var invoker = GenericServiceCache <ITriggerInvoker, TriggerInvoker <DbContext> > .GetOrAdd(dbContext.GetType());
var swallow = false;
try {
var afterActions = invoker.RaiseChangingEvents(dbContext, serviceProvider);
#if EF_CORE
var result = baseSaveChanges(acceptAllChangesOnSuccess);
#else
var result = baseSaveChanges();
#endif
invoker.RaiseChangedEvents(dbContext, serviceProvider, afterActions);
return(result);
}
catch (DbUpdateException ex) when(invoker.RaiseFailedEvents(dbContext, serviceProvider, ex, ref swallow))
{
}
#if !EF_CORE
catch (DbEntityValidationException ex) when(invoker.RaiseFailedEvents(dbContext, serviceProvider, ex, ref swallow))
{
}
#endif
catch (Exception ex) when(invoker.RaiseFailedEvents(dbContext, serviceProvider, ex, ref swallow))
{
}
return(0);
}
public static async Task <Int32> SaveChangesWithTriggersAsync(this DbContext dbContext, Func <CancellationToken, Task <Int32> > baseSaveChangesAsync, IServiceProvider serviceProvider, CancellationToken cancellationToken = default)
{
#endif
if (dbContext == null)
{
throw new ArgumentNullException(nameof(dbContext));
}
var invoker = GenericServiceCache <ITriggerInvokerAsync, TriggerInvokerAsync <DbContext> > .GetOrAdd(dbContext.GetType());
try {
var afterActions = await invoker.RaiseChangingEventsAsync(dbContext, serviceProvider);
#if EF_CORE
var result = await baseSaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken).ConfigureAwait(false);
#else
var result = await baseSaveChangesAsync(cancellationToken).ConfigureAwait(false);
#endif
await invoker.RaiseChangedEventsAsync(dbContext, serviceProvider, afterActions);
return(result);
}
catch (DbUpdateException ex) {
var swallow = await invoker.RaiseFailedEventsAsync(dbContext, serviceProvider, ex);
if (!swallow)
{
throw;
}
}
#if !EF_CORE
catch (DbEntityValidationException ex) {
var swallow = await invoker.RaiseFailedEventsAsync(dbContext, serviceProvider, ex);
if (!swallow)
{
throw;
}
}
#endif
catch (Exception ex) {
var swallow = await invoker.RaiseFailedEventsAsync(dbContext, serviceProvider, ex);
if (!swallow)
{
throw;
}
}
return(0);
}
private static void RaiseTheFailedEvents(TDbContext dbContext, IServiceProvider serviceProvider, EntityEntry entry, Exception exception, ref Boolean swallow)
{
switch (entry.State)
{
case EntityState.Added:
GetTriggerEntityInvoker(entry.Entity.GetType()).RaiseInsertFailed(serviceProvider, entry.Entity, dbContext, exception, ref swallow);
break;
case EntityState.Modified:
GetTriggerEntityInvoker(entry.Entity.GetType()).RaiseUpdateFailed(serviceProvider, entry.Entity, dbContext, exception, ref swallow);
break;
case EntityState.Deleted:
GetTriggerEntityInvoker(entry.Entity.GetType()).RaiseDeleteFailed(serviceProvider, entry.Entity, dbContext, exception, ref swallow);
break;
}
ITriggerEntityInvoker <TDbContext> GetTriggerEntityInvoker(Type entityType) =>
GenericServiceCache <ITriggerEntityInvoker <TDbContext>, TriggerEntityInvoker <TDbContext, Object> > .GetOrAdd(dbContext.GetType(), entityType);
}
private static DelegateSynchronyUnion <DbContext>?RaiseChangingEvent(EntityEntry entry, DbContext dbContext, IServiceProvider serviceProvider, ref Boolean cancel)
{
var tDbContext = (TDbContext)dbContext;
var entityType = entry.Entity.GetType();
var triggerEntityInvoker = GenericServiceCache <ITriggerEntityInvoker <TDbContext>, TriggerEntityInvoker <TDbContext, Object> > .GetOrAdd(dbContext.GetType(), entityType);
switch (entry.State)
{
case EntityState.Added:
triggerEntityInvoker.RaiseInserting(serviceProvider, entry.Entity, tDbContext, ref cancel);
return(new DelegateSynchronyUnion <DbContext>(context => triggerEntityInvoker.RaiseInserted(serviceProvider, entry.Entity, (TDbContext)context)));
case EntityState.Deleted:
triggerEntityInvoker.RaiseDeleting(serviceProvider, entry.Entity, tDbContext, ref cancel);
return(new DelegateSynchronyUnion <DbContext>(context => triggerEntityInvoker.RaiseDeleted(serviceProvider, entry.Entity, (TDbContext)context)));
case EntityState.Modified:
triggerEntityInvoker.RaiseUpdating(serviceProvider, entry.Entity, tDbContext, ref cancel);
return(new DelegateSynchronyUnion <DbContext>(context => triggerEntityInvoker.RaiseUpdated(serviceProvider, entry.Entity, (TDbContext)context)));
}
return(null);
}
private static async Task <(DelegateSynchronyUnion <DbContext>?, Boolean)> RaiseChangingEventAsync(EntityEntry entry, DbContext dbContext, IServiceProvider serviceProvider, Boolean cancel)
{
var tDbContext = (TDbContext)dbContext;
var entityType = entry.Entity.GetType();
var triggerEntityInvoker = GenericServiceCache <ITriggerEntityInvoker <TDbContext>, TriggerEntityInvoker <TDbContext, Object> > .GetOrAdd(tDbContext.GetType(), entityType);
switch (entry.State)
{
case EntityState.Added:
cancel = await triggerEntityInvoker.RaiseInsertingAsync(serviceProvider, entry.Entity, tDbContext, cancel);
return(new DelegateSynchronyUnion <DbContext>(context => triggerEntityInvoker.RaiseInsertedAsync(serviceProvider, entry.Entity, (TDbContext)context)), cancel);
case EntityState.Deleted:
cancel = await triggerEntityInvoker.RaiseDeletingAsync(serviceProvider, entry.Entity, tDbContext, cancel);
return(new DelegateSynchronyUnion <DbContext>(context => triggerEntityInvoker.RaiseDeletedAsync(serviceProvider, entry.Entity, (TDbContext)context)), cancel);
case EntityState.Modified:
cancel = await triggerEntityInvoker.RaiseUpdatingAsync(serviceProvider, entry.Entity, tDbContext, cancel);
return(new DelegateSynchronyUnion <DbContext>(context => triggerEntityInvoker.RaiseUpdatedAsync(serviceProvider, entry.Entity, (TDbContext)context)), cancel);
}
return(default);
