Introducting synchronous triggers.

benchmarks/EntityFrameworkCore.Triggered.Benchmarks/Triggers/SetStudentRegistrationDateTrigger.cs

@@ -6,10 +6,9 @@ namespace EntityFrameworkCore.Triggered.Benchmarks.Triggers
 {
     public class SetStudentRegistrationDateTrigger : IBeforeSaveTrigger<Student>
     {
-        public Task BeforeSave(ITriggerContext<Student> context, CancellationToken cancellationToken)
+        public void BeforeSave(ITriggerContext<Student> context)
         {
             context.Entity.RegistrationDate = DateTimeOffset.Now;
-            return Task.CompletedTask;
         }
     }
 }

benchmarks/EntityFrameworkCore.Triggered.Benchmarks/Triggers/SignStudentUpForMandatoryCourses.cs

@@ -13,7 +13,7 @@ public SignStudentUpForMandatoryCourses(TriggeredApplicationContext applicationC
             _applicationContext = applicationContext;
         }
 
-        public Task BeforeSave(ITriggerContext<Student> context, CancellationToken cancellationToken)
+        public void BeforeSave(ITriggerContext<Student> context)
         {
             var mandatoryCourses = _applicationContext.Courses.Where(x => x.IsMandatory).ToList();
 
@@ -24,8 +24,6 @@ public Task BeforeSave(ITriggerContext<Student> context, CancellationToken cance
                     StudentId = context.Entity.Id
                 });
             }
-
-            return Task.CompletedTask;
         }
     }
 }

src/EntityFrameworkCore.Triggered.Abstractions/IAfterSaveAsyncTrigger.cs

@@ -0,0 +1,11 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered
+{
+    public interface IAfterSaveAsyncTrigger<TEntity>
+        where TEntity : class
+    {
+        Task AfterSaveAsync(ITriggerContext<TEntity> context, CancellationToken cancellationToken);
+    }
+}

src/EntityFrameworkCore.Triggered.Abstractions/IAfterSaveFailedAsyncTrigger.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered
+{
+    public interface IAfterSaveFailedAsyncTrigger<TEntity>
+        where TEntity : class
+    {
+        Task AfterSaveFailedAsync(ITriggerContext<TEntity> context, Exception exception, CancellationToken cancellationToken);
+    }
+
+
+}

src/EntityFrameworkCore.Triggered.Abstractions/IAfterSaveFailedTrigger.cs

@@ -1,12 +1,12 @@
 using System;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace EntityFrameworkCore.Triggered
 {
     public interface IAfterSaveFailedTrigger<TEntity>
         where TEntity : class
     {
-        Task AfterSaveFailed(ITriggerContext<TEntity> context, Exception exception, CancellationToken cancellationToken);
+        void AfterSaveFailed(ITriggerContext<TEntity> context, Exception exception);
     }
+
+
 }

src/EntityFrameworkCore.Triggered.Abstractions/IAfterSaveTrigger.cs

@@ -1,11 +1,8 @@
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace EntityFrameworkCore.Triggered
+namespace EntityFrameworkCore.Triggered
 {
     public interface IAfterSaveTrigger<TEntity>
         where TEntity : class
     {
-        Task AfterSave(ITriggerContext<TEntity> context, CancellationToken cancellationToken);
+        void AfterSave(ITriggerContext<TEntity> context);
     }
 }

src/EntityFrameworkCore.Triggered.Abstractions/IBeforeSaveAsyncTrigger.cs

@@ -0,0 +1,11 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered
+{
+    public interface IBeforeSaveAsyncTrigger<in TEntity>
+        where TEntity : class
+    {
+        Task BeforeSaveAsync(ITriggerContext<TEntity> context, CancellationToken cancellationToken);
+    }
+}

src/EntityFrameworkCore.Triggered.Abstractions/IBeforeSaveTrigger.cs

@@ -1,11 +1,8 @@
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace EntityFrameworkCore.Triggered
+namespace EntityFrameworkCore.Triggered
 {
     public interface IBeforeSaveTrigger<in TEntity>
         where TEntity : class
     {
-        Task BeforeSave(ITriggerContext<TEntity> context, CancellationToken cancellationToken);
+        void BeforeSave(ITriggerContext<TEntity> context);
     }
 }

src/EntityFrameworkCore.Triggered.Abstractions/ITriggerSession.cs

@@ -10,32 +10,55 @@ public interface ITriggerSession : IDisposable
         /// Discoveres any new pending changes in the DbContext
         /// </summary>
         void DiscoverChanges();
-        Task RaiseBeforeSaveStartingTriggers(CancellationToken cancellationToken = default);
-        Task RaiseBeforeSaveCompletedTriggers(CancellationToken cancellationToken = default);
-        Task RaiseAfterSaveFailedStartingTriggers(Exception exception, CancellationToken cancellationToken = default);
-        Task RaiseAfterSaveFailedCompletedTriggers(Exception exception, CancellationToken cancellationToken = default);
-        Task RaiseAfterSaveStartingTriggers(CancellationToken cancellationToken = default);
-        Task RaiseAfterSaveCompletedTriggers(CancellationToken cancellationToken = default);
+        void RaiseBeforeSaveStartingTriggers();
+        void RaiseBeforeSaveCompletedTriggers();
+        void RaiseAfterSaveFailedStartingTriggers(Exception exception);
+        void RaiseAfterSaveFailedCompletedTriggers(Exception exception);
+        void RaiseAfterSaveStartingTriggers();
+        void RaiseAfterSaveCompletedTriggers();
+        Task RaiseBeforeSaveStartingAsyncTriggers(CancellationToken cancellationToken = default);
+        Task RaiseBeforeSaveCompletedAsyncTriggers(CancellationToken cancellationToken = default);
+        Task RaiseAfterSaveFailedStartingAsyncTriggers(Exception exception, CancellationToken cancellationToken = default);
+        Task RaiseAfterSaveFailedCompletedAsyncTriggers(Exception exception, CancellationToken cancellationToken = default);
+        Task RaiseAfterSaveStartingAsyncTriggers(CancellationToken cancellationToken = default);
+        Task RaiseAfterSaveCompletedAsyncTriggers(CancellationToken cancellationToken = default);
         /// <summary>
         /// Makes a snapshot of all changes in the DbContext and invokes BeforeSaveTriggers while detecting and cascading based on the cascade settings until all changes have been processed
         /// </summary>
-        Task RaiseBeforeSaveTriggers(CancellationToken cancellationToken = default);
+        void RaiseBeforeSaveTriggers();
+        /// <summary>
+        /// Makes a snapshot of all changes in the DbContext and invokes BeforeSaveTriggers while detecting and cascading based on the cascade settings until all changes have been processed
+        /// </summary>
+        Task RaiseBeforeSaveAsyncTriggers(CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Makes a snapshot of all changes in the DbContext and invokes BeforeSaveTriggers while detecting and cascading based on the cascade settings until all changes have been processed
+        /// </summary>
+        /// <param name="skipDetectedChanges">Allows BeforeSaveTriggers not to include previously detected changes. Only new changes will be detected and fired upon. This is useful in case of multiple calls to RaiseBeforeSaveTriggers</param>
+        void RaiseBeforeSaveTriggers(bool skipDetectedChanges);
         /// <summary>
         /// Makes a snapshot of all changes in the DbContext and invokes BeforeSaveTriggers while detecting and cascading based on the cascade settings until all changes have been processed
         /// </summary>
         /// <param name="skipDetectedChanges">Allows BeforeSaveTriggers not to include previously detected changes. Only new changes will be detected and fired upon. This is useful in case of multiple calls to RaiseBeforeSaveTriggers</param>
-        Task RaiseBeforeSaveTriggers(bool skipDetectedChanges, CancellationToken cancellationToken = default);
+        Task RaiseBeforeSaveAsyncTriggers(bool skipDetectedChanges, CancellationToken cancellationToken = default);
         /// <summary>
         /// Captures and locks all discovered changes
         /// </summary>
         void CaptureDiscoveredChanges();
         /// <summary>
         /// Invokes AfterSaveTriggers. Calling this method expects that either RaiseBeforeSaveTriggers() or DiscoverChanges() has been called
         /// </summary>
-        Task RaiseAfterSaveTriggers(CancellationToken cancellationToken = default);
+        void RaiseAfterSaveTriggers();
+        /// <summary>
+        /// Invokes AfterSaveTriggers. Calling this method expects that either RaiseBeforeSaveTriggers() or DiscoverChanges() has been called
+        /// </summary>
+        Task RaiseAfterSaveAsyncTriggers(CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Invokes AfterSaveFailedTriggers. Calling this method expects that either RaiseBeforeSaveTriggers() or DiscoverChanges() has been called
+        /// </summary>
+        void RaiseAfterSaveFailedTriggers(Exception exception);
         /// <summary>
         /// Invokes AfterSaveFailedTriggers. Calling this method expects that either RaiseBeforeSaveTriggers() or DiscoverChanges() has been called
         /// </summary>
-        Task RaiseAfterSaveFailedTriggers(Exception exception, CancellationToken cancellationToken = default);
+        Task RaiseAfterSaveFailedAsyncTriggers(Exception exception, CancellationToken cancellationToken = default);
     }
 }

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IAfterSaveCompletedAsyncTrigger.cs

@@ -0,0 +1,10 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered.Lifecycles
+{
+    public interface IAfterSaveCompletedAsyncTrigger
+    {
+        Task AfterSaveCompletedAsync(CancellationToken cancellationToken);
+    }
+}

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IAfterSaveCompletedTrigger.cs

@@ -1,10 +1,7 @@
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace EntityFrameworkCore.Triggered.Lifecycles
+namespace EntityFrameworkCore.Triggered.Lifecycles
 {
     public interface IAfterSaveCompletedTrigger
     {
-        Task AfterSaveCompleted(CancellationToken cancellationToken);
+        void AfterSaveCompleted();
     }
 }

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IAfterSaveFailedCompletedAsyncTrigger.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered.Lifecycles
+{
+    public interface IAfterSaveFailedCompletedAsyncTrigger
+    {
+        Task AfterSaveFailedCompletedAsync(Exception exception, CancellationToken cancellationToken);
+    }
+}

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IAfterSaveFailedCompletedTrigger.cs

@@ -1,11 +1,9 @@
 using System;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace EntityFrameworkCore.Triggered.Lifecycles
 {
     public interface IAfterSaveFailedCompletedTrigger
     {
-        Task AfterSaveFailedCompleted(Exception exception, CancellationToken cancellationToken);
+        void AfterSaveFailedCompleted(Exception exception);
     }
 }

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IAfterSaveFailedStartingAsyncTrigger.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered.Lifecycles
+{
+    public interface IAfterSaveFailedStartingAsyncTrigger
+    {
+        Task AfterSaveFailedStartingAsync(Exception exception, CancellationToken cancellationToken);
+    }
+}

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IAfterSaveFailedStartingTrigger.cs

@@ -1,11 +1,9 @@
 using System;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace EntityFrameworkCore.Triggered.Lifecycles
 {
     public interface IAfterSaveFailedStartingTrigger
     {
-        Task AfterSaveFailedStarting(Exception exception, CancellationToken cancellationToken);
+        void AfterSaveFailedStarting(Exception exception);
     }
 }

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IAfterSaveStartingAsyncTrigger.cs

@@ -0,0 +1,10 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered.Lifecycles
+{
+    public interface IAfterSaveStartingAsyncTrigger
+    {
+        Task AfterSaveStartingAsync(CancellationToken cancellationToken);
+    }
+}

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IAfterSaveStartingTrigger.cs

@@ -1,10 +1,7 @@
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace EntityFrameworkCore.Triggered.Lifecycles
+namespace EntityFrameworkCore.Triggered.Lifecycles
 {
     public interface IAfterSaveStartingTrigger
     {
-        Task AfterSaveStarting(CancellationToken cancellationToken);
+        void AfterSaveStarting();
     }
 }

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IBeforeSaveCompletedAsyncTrigger.cs

@@ -0,0 +1,10 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered.Lifecycles
+{
+    public interface IBeforeSaveCompletedAsyncTrigger
+    {
+        Task BeforeSaveCompletedAsync(CancellationToken cancellationToken);
+    }
+}

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IBeforeSaveCompletedTrigger.cs

@@ -1,10 +1,7 @@
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace EntityFrameworkCore.Triggered.Lifecycles
+namespace EntityFrameworkCore.Triggered.Lifecycles
 {
     public interface IBeforeSaveCompletedTrigger
     {
-        Task BeforeSaveCompleted(CancellationToken cancellationToken);
+        void BeforeSaveCompleted();
     }
 }

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IBeforeSaveStartingAsyncTrigger.cs

@@ -0,0 +1,10 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered.Lifecycles
+{
+    public interface IBeforeSaveStartingAsyncTrigger
+    {
+        Task BeforeSaveStartingAsync(CancellationToken cancellationToken);
+    }
+}

src/EntityFrameworkCore.Triggered.Abstractions/Lifecycles/IBeforeSaveStartingTrigger.cs

@@ -1,10 +1,7 @@
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace EntityFrameworkCore.Triggered.Lifecycles
+namespace EntityFrameworkCore.Triggered.Lifecycles
 {
     public interface IBeforeSaveStartingTrigger
     {
-        Task BeforeSaveStarting(CancellationToken cancellationToken);
+        void BeforeSaveStarting();
     }
 }

src/EntityFrameworkCore.Triggered.Extensions/ServiceCollectionExtensions.cs

@@ -12,14 +12,23 @@ public static class ServiceCollectionExtensions
     {
         static readonly Type[] _wellKnownTriggerTypes = new Type[] {
                 typeof(IBeforeSaveTrigger<>),
+                typeof(IBeforeSaveAsyncTrigger<>),
                 typeof(IAfterSaveTrigger<>),
+                typeof(IAfterSaveAsyncTrigger<>),
                 typeof(IAfterSaveFailedTrigger<>),
+                typeof(IAfterSaveFailedAsyncTrigger<>),
                 typeof(IBeforeSaveStartingTrigger),
+                typeof(IBeforeSaveStartingAsyncTrigger),
                 typeof(IBeforeSaveCompletedTrigger),
+                typeof(IBeforeSaveCompletedAsyncTrigger),
                 typeof(IAfterSaveFailedStartingTrigger),
+                typeof(IAfterSaveFailedStartingAsyncTrigger),
                 typeof(IAfterSaveFailedCompletedTrigger),
+                typeof(IAfterSaveFailedCompletedAsyncTrigger),
                 typeof(IAfterSaveStartingTrigger),
-                typeof(IAfterSaveCompletedTrigger)
+                typeof(IAfterSaveStartingAsyncTrigger),
+                typeof(IAfterSaveCompletedTrigger),
+                typeof(IAfterSaveCompletedAsyncTrigger)
             };
 
         static void RegisterTriggerTypes(Type triggerImplementationType, IServiceCollection services)

src/EntityFrameworkCore.Triggered.Extensions/Trigger.cs

@@ -6,35 +6,19 @@ namespace EntityFrameworkCore.Triggered.Extensions
 {
     public class Trigger<TEntity> :
         IBeforeSaveTrigger<TEntity>,
+        IBeforeSaveAsyncTrigger<TEntity>,
         IAfterSaveTrigger<TEntity>,
-        IAfterSaveFailedTrigger<TEntity>
+        IAfterSaveAsyncTrigger<TEntity>,
+        IAfterSaveFailedTrigger<TEntity>,
+        IAfterSaveFailedAsyncTrigger<TEntity>
 
         where TEntity : class
     {
         public virtual void BeforeSave(ITriggerContext<TEntity> context) { }
         public virtual void AfterSave(ITriggerContext<TEntity> context) { }
         public virtual void AfterSaveFailed(ITriggerContext<TEntity> context, Exception exception) { }
-
-        public virtual Task BeforeSave(ITriggerContext<TEntity> context, CancellationToken cancellationToken) => Task.CompletedTask;
-        public virtual Task AfterSave(ITriggerContext<TEntity> context, CancellationToken cancellationToken) => Task.CompletedTask;
-        public virtual Task AfterSaveFailed(ITriggerContext<TEntity> context, Exception exception, CancellationToken cancellationToken) => Task.CompletedTask;
-
-        Task IBeforeSaveTrigger<TEntity>.BeforeSave(ITriggerContext<TEntity> context, CancellationToken cancellationToken)
-        {
-            BeforeSave(context);
-            return BeforeSave(context, cancellationToken);
-        }
-
-        Task IAfterSaveTrigger<TEntity>.AfterSave(ITriggerContext<TEntity> context, CancellationToken cancellationToken)
-        {
-            AfterSave(context);
-            return AfterSave(context, cancellationToken);
-        }
-
-        Task IAfterSaveFailedTrigger<TEntity>.AfterSaveFailed(ITriggerContext<TEntity> context, Exception exception, CancellationToken cancellationToken)
-        {
-            AfterSaveFailed(context, exception);
-            return AfterSaveFailed(context, exception, cancellationToken);
-        }
+        public virtual Task BeforeSaveAsync(ITriggerContext<TEntity> context, CancellationToken cancellationToken) => Task.CompletedTask;
+        public virtual Task AfterSaveAsync(ITriggerContext<TEntity> context, CancellationToken cancellationToken) => Task.CompletedTask;
+        public virtual Task AfterSaveFailedAsync(ITriggerContext<TEntity> context, Exception exception, CancellationToken cancellationToken) => Task.CompletedTask;
     }
 }