Merge pull request #117 from koenbeuk/trigger-service-configuration

Trigger service configuration

Author: koenbeuk

src/EntityFrameworkCore.Triggered.Abstractions/Internal/IsExternalInit.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if NETSTANDARD2_0 || NETSTANDARD2_1 || NETCOREAPP2_0 || NETCOREAPP2_1 || NETCOREAPP2_2 || NETCOREAPP3_0 || NETCOREAPP3_1 || NET45 || NET451 || NET452 || NET6 || NET461 || NET462 || NET47 || NET471 || NET472 || NET48
+
+using System.ComponentModel;
+
+// ReSharper disable once CheckNamespace
+namespace System.Runtime.CompilerServices
+{
+    /// <summary>
+    /// Reserved to be used by the compiler for tracking metadata.
+    /// This class should not be used by developers in source code.
+    /// </summary>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    internal static class IsExternalInit
+    {
+    }
+}
+
+#endif

src/EntityFrameworkCore.Triggered.Abstractions/TriggerConfiguration.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered
+{
+    public record TriggerConfiguration
+    {
+        public TriggerConfiguration(bool disabled, int maxCascadeCycles)
+        {
+            Disabled = disabled;
+            MaxCascadeCycles = maxCascadeCycles;
+        }
+
+        public bool Disabled { get; init; }
+
+        public int MaxCascadeCycles { get; init; }
+    }
+}

src/EntityFrameworkCore.Triggered/Extensions/DbContextExtensions.cs

@@ -1,16 +1,80 @@
 using System;
+using System.Threading.Tasks;
+using System.Threading;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 
 namespace EntityFrameworkCore.Triggered.Extensions
 {
     public static class DbContextExtensions
     {
+        /// <summary>
+        /// Gets the <c>ITriggerService</c> that is used to create trigger sessions.Allows for just in time configuration
+        /// </summary>
+        public static ITriggerService GetTriggerService(this DbContext dbContext)
+        {
+            if (dbContext is null)
+            {
+                throw new ArgumentNullException(nameof(dbContext));
+            }
+
+            return dbContext.GetService<ITriggerService>() ?? throw new InvalidOperationException("Triggers are not configured for this DbContext");
+        }
+
+        /// <summary>
+        /// Gets or creates a <c>ITriggerSession</c> that can be used to manually invoke triggers
+        /// </summary>
         public static ITriggerSession CreateTriggerSession(this DbContext dbContext, IServiceProvider? serviceProvider = null)
         {
-            var triggerService = dbContext.GetService<ITriggerService>() ?? throw new InvalidOperationException("Trigger service infrastructure is not configured");
+            var triggerService = GetTriggerService(dbContext);
 
             return triggerService.CreateSession(dbContext, serviceProvider);
         }
+
+        /// <summary>
+        /// Calls dbContext.SaveChanges without invoking triggers
+        /// </summary>
+        public static int SaveChangesWithoutTriggers(this DbContext dbContext, bool acceptAllChangesOnSuccess = true)
+        {
+            var triggerService = GetTriggerService(dbContext);
+            var initialConfiguration = triggerService.Configuration;
+
+            try
+            {
+                triggerService.Configuration = initialConfiguration with { Disabled = true };
+
+                return dbContext.SaveChanges(acceptAllChangesOnSuccess);
+            }
+            finally
+            {
+                triggerService.Configuration = initialConfiguration;
+            }
+        }
+
+        /// <summary>
+        /// Calls dbContext.SaveChanges without invoking triggers
+        /// </summary>
+        public static Task<int> SaveChangesWithoutTriggersAsync(this DbContext dbContext, CancellationToken cancellationToken = default)
+            => SaveChangesWithoutTriggersAsync(dbContext, true, cancellationToken);
+
+        /// <summary>
+        /// Calls dbContext.SaveChanges without invoking triggers
+        /// </summary>
+        public static Task<int> SaveChangesWithoutTriggersAsync(this DbContext dbContext, bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default)
+        {
+            var triggerService = GetTriggerService(dbContext);
+            var initialConfiguration = triggerService.Configuration;
+
+            try
+            {
+                triggerService.Configuration = initialConfiguration with { Disabled = true };
+
+                return dbContext.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
+            }
+            finally
+            {
+                triggerService.Configuration = initialConfiguration;
+            }
+        }
     }
 }

src/EntityFrameworkCore.Triggered/ITriggerService.cs

@@ -5,6 +5,8 @@ namespace EntityFrameworkCore.Triggered
 {
     public interface ITriggerService
     {
+        TriggerConfiguration Configuration { get; set; }
+
         ITriggerSession CreateSession(DbContext context, IServiceProvider? serviceProvider = null);
 
         ITriggerSession? Current { get; set; }

src/EntityFrameworkCore.Triggered/Internal/CascadingTriggerContextDiscoveryStrategy.cs

@@ -26,9 +26,9 @@ public CascadingTriggerContextDiscoveryStrategy(string name, bool skipDetectedCh
             _skipDetectedChanges = skipDetectedChanges;
         }
 
-        public IEnumerable<IEnumerable<TriggerContextDescriptor>> Discover(TriggerOptions options, TriggerContextTracker tracker, ILogger logger)
+        public IEnumerable<IEnumerable<TriggerContextDescriptor>> Discover(TriggerConfiguration configuration, TriggerContextTracker tracker, ILogger logger)
         {
-            var maxCascadingCycles = options.MaxCascadeCycles;
+            var maxCascadingCycles = configuration.MaxCascadeCycles;
             _discoveryStarted(logger, _name, maxCascadingCycles, null);
 
             var iteration = 0;

src/EntityFrameworkCore.Triggered/Internal/ITriggerContextDiscoveryStrategy.cs

@@ -5,6 +5,6 @@ namespace EntityFrameworkCore.Triggered.Internal
 {
     public interface ITriggerContextDiscoveryStrategy
     {
-        IEnumerable<IEnumerable<TriggerContextDescriptor>> Discover(TriggerOptions options, TriggerContextTracker tracker, ILogger logger);
+        IEnumerable<IEnumerable<TriggerContextDescriptor>> Discover(TriggerConfiguration configuration, TriggerContextTracker tracker, ILogger logger);
     }
 }

src/EntityFrameworkCore.Triggered/Internal/NonCascadingTriggerContextDiscoveryStrategy.cs

@@ -19,7 +19,7 @@ public NonCascadingTriggerContextDiscoveryStrategy(string name)
             _name = name ?? throw new ArgumentNullException(nameof(name));
         }
 
-        public IEnumerable<IEnumerable<TriggerContextDescriptor>> Discover(TriggerOptions options, TriggerContextTracker tracker, ILogger logger)
+        public IEnumerable<IEnumerable<TriggerContextDescriptor>> Discover(TriggerConfiguration configuration, TriggerContextTracker tracker, ILogger logger)
         {
             var changes = tracker.DiscoveredChanges ?? throw new InvalidOperationException("Trigger discovery process has not yet started. Please ensure that TriggerSession.DiscoverChanges() or TriggerSession.RaiseBeforeSaveTriggers() has been called");
 

src/EntityFrameworkCore.Triggered/TriggerService.cs

@@ -12,19 +12,22 @@ namespace EntityFrameworkCore.Triggered
 {
     public class TriggerService : ITriggerService, IResettableService
     {
+
         readonly ITriggerDiscoveryService _triggerDiscoveryService;
         readonly ICascadeStrategy _cascadingStrategy;
         readonly ILoggerFactory _loggerFactory;
-        readonly TriggerOptions _options;
+        readonly TriggerConfiguration _defaultConfiguration;
 
         ITriggerSession? _currentTriggerSession;
 
-        public TriggerService(ITriggerDiscoveryService triggerDiscoveryService, ICascadeStrategy cascadingStrategy, ILoggerFactory loggerFactory, IOptionsSnapshot<TriggerOptions> triggerOptionsSnapshot)
+        public TriggerService(ITriggerDiscoveryService triggerDiscoveryService, ICascadeStrategy cascadingStrategy, ILoggerFactory loggerFactory, IOptions<TriggerOptions> triggerOptions)
         {
             _triggerDiscoveryService = triggerDiscoveryService ?? throw new ArgumentNullException(nameof(triggerDiscoveryService));
             _cascadingStrategy = cascadingStrategy ?? throw new ArgumentNullException(nameof(cascadingStrategy));
             _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
-            _options = triggerOptionsSnapshot.Value;
+            _defaultConfiguration = new TriggerConfiguration(false, triggerOptions.Value.MaxCascadeCycles);
+            
+            Configuration = _defaultConfiguration;
         }
 
         public ITriggerSession? Current
@@ -33,6 +36,8 @@ public ITriggerSession? Current
             set => _currentTriggerSession = value;
         }
 
+        public TriggerConfiguration Configuration { get; set; }
+
         public ITriggerSession CreateSession(DbContext context, IServiceProvider? serviceProvider)
         {
             if (context is null)
@@ -47,7 +52,7 @@ public ITriggerSession CreateSession(DbContext context, IServiceProvider? servic
                 _triggerDiscoveryService.ServiceProvider = serviceProvider;
             }
 
-            var triggerSession = new TriggerSession(this, _options, _triggerDiscoveryService, triggerContextTracker, _loggerFactory.CreateLogger<TriggerSession>());
+            var triggerSession = new TriggerSession(this, Configuration, _triggerDiscoveryService, triggerContextTracker, _loggerFactory.CreateLogger<TriggerSession>());
 
             _currentTriggerSession = triggerSession;
 
@@ -61,6 +66,8 @@ public void ResetState()
                 _currentTriggerSession.Dispose();
                 _currentTriggerSession = null;
             }
+
+            Configuration = _defaultConfiguration;
         }
 
         public Task ResetStateAsync(CancellationToken cancellationToken = default)

src/EntityFrameworkCore.Triggered/TriggerSession.cs

@@ -17,17 +17,17 @@ public class TriggerSession : ITriggerSession
         static ITriggerContextDiscoveryStrategy? _afterSaveFailedTriggerContextDiscoveryStrategy;
 
         readonly ITriggerService _triggerService;
-        readonly TriggerOptions _options;
+        readonly TriggerConfiguration _configuration;
         readonly ITriggerDiscoveryService _triggerDiscoveryService;
         readonly TriggerContextTracker _tracker;
         readonly ILogger<TriggerSession> _logger;
 
         bool _raiseBeforeSaveTriggersCalled;
 
-        public TriggerSession(ITriggerService triggerService, TriggerOptions options, ITriggerDiscoveryService triggerDiscoveryService, TriggerContextTracker tracker, ILogger<TriggerSession> logger)
+        public TriggerSession(ITriggerService triggerService, TriggerConfiguration configuration, ITriggerDiscoveryService triggerDiscoveryService, TriggerContextTracker tracker, ILogger<TriggerSession> logger)
         {
             _triggerService = triggerService ?? throw new ArgumentNullException(nameof(triggerService));
-            _options = options ?? throw new ArgumentNullException(nameof(options));
+            _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
             _triggerDiscoveryService = triggerDiscoveryService ?? throw new ArgumentNullException(nameof(triggerDiscoveryService));
             _tracker = tracker ?? throw new ArgumentNullException(nameof(tracker));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
@@ -48,9 +48,14 @@ public async Task RaiseTriggers(Type openTriggerType, Exception? exception, ITri
                 throw new ArgumentNullException(nameof(triggerContextDiscoveryStrategy));
             }
 
+            if (_configuration.Disabled)
+            {
+                return;
+            }
+
             cancellationToken.ThrowIfCancellationRequested();
 
-            var triggerContextDescriptorBatches = triggerContextDiscoveryStrategy.Discover(_options, _tracker, _logger);
+            var triggerContextDescriptorBatches = triggerContextDiscoveryStrategy.Discover(_configuration, _tracker, _logger);
             foreach (var triggerContextDescriptorBatch in triggerContextDescriptorBatches)
             {
                 List<(TriggerContextDescriptor triggerContextDescriptor, TriggerDescriptor triggerDescriptor)>? triggerInvocations = null;

src/EntityFrameworkCore.Triggered/TriggeredDbContext.cs

@@ -48,7 +48,7 @@ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
 
         public void SetTriggerServiceProvider(IServiceProvider? serviceProvider)
             => _triggerServiceProvider = serviceProvider;
-
+        
         public override int SaveChanges(bool acceptAllChangesOnSuccess)
         {
             bool RaiseAfterSavFailedTriggers(Exception exception)
@@ -62,11 +62,11 @@ bool RaiseAfterSavFailedTriggers(Exception exception)
 
             var createdTriggerSession = false;
 
-            if (_triggerSession == null)
+            if (_triggerSession is null)
             {
                 var triggerService = this.GetService<ITriggerService>() ?? throw new InvalidOperationException("Triggers are not configured");
 
-                if (triggerService.Current != null)
+                if (triggerService.Current is not null)
                 {
                     _triggerSession = triggerService.Current;
                 }