Fixed extensions project

koenbeuk · koenbeuk · commit 4c66333bf0c1 · 2022-10-21T00:25:57.000+01:00
diff --git a/src/EntityFrameworkCore.Triggered.Extensions/ServiceCollectionExtensions.cs b/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)
diff --git a/src/EntityFrameworkCore.Triggered/Infrastructure/Internal/TriggersOptionExtension.cs b/src/EntityFrameworkCore.Triggered/Infrastructure/Internal/TriggersOptionExtension.cs
@@ -101,14 +101,23 @@ public TriggersOptionExtension()
         {
             _triggerTypes = new[] {
                 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)
             };
         }
 
diff --git a/src/EntityFrameworkCore.Triggered/Internal/Descriptors/AfterSaveFailedAsyncTriggerDescriptor.cs b/src/EntityFrameworkCore.Triggered/Internal/Descriptors/AfterSaveFailedAsyncTriggerDescriptor.cs
@@ -11,8 +11,8 @@ public sealed class AfterSaveFailedAsyncTriggerDescriptor : IAsyncTriggerTypeDes
 
         public AfterSaveFailedAsyncTriggerDescriptor(Type entityType)
         {
-            var triggerType = typeof(IAfterSaveFailedTrigger<>).MakeGenericType(entityType);
-            var triggerMethod = triggerType.GetMethod(nameof(IAfterSaveFailedTrigger<object>.AfterSaveFailed));
+            var triggerType = typeof(IAfterSaveFailedAsyncTrigger<>).MakeGenericType(entityType);
+            var triggerMethod = triggerType.GetMethod(nameof(IAfterSaveFailedAsyncTrigger<object>.AfterSaveFailedAsync));
 
             _triggerType = triggerType;
             _invocationDelegate = TriggerTypeDescriptorHelpers.GetAsyncWeakDelegateWithException(triggerType, entityType, triggerMethod!);
diff --git a/src/EntityFrameworkCore.Triggered/Internal/Descriptors/BeforeSaveAsyncTriggerDescriptor.cs b/src/EntityFrameworkCore.Triggered/Internal/Descriptors/BeforeSaveAsyncTriggerDescriptor.cs
@@ -12,8 +12,8 @@ public sealed class BeforeSaveAsyncTriggerDescriptor : IAsyncTriggerTypeDescript
 
         public BeforeSaveAsyncTriggerDescriptor(Type entityType)
         {
-            var triggerType = typeof(IBeforeSaveTrigger<>).MakeGenericType(entityType);
-            var triggerMethod = triggerType.GetMethod(nameof(IBeforeSaveTrigger<object>.BeforeSave));
+            var triggerType = typeof(IBeforeSaveAsyncTrigger<>).MakeGenericType(entityType);
+            var triggerMethod = triggerType.GetMethod(nameof(IBeforeSaveAsyncTrigger<object>.BeforeSaveAsync));
 
             _triggerType = triggerType;
             _invocationDelegate = TriggerTypeDescriptorHelpers.GetAsyncWeakDelegate(triggerType, entityType, triggerMethod!);
diff --git a/src/EntityFrameworkCore.Triggered/Internal/TriggerTypeDescriptorHelpers.cs b/src/EntityFrameworkCore.Triggered/Internal/TriggerTypeDescriptorHelpers.cs
@@ -41,7 +41,7 @@ static Action<object, object> GetWeakDelegateHelper<TTriggerType, TTriggerContex
         static Action<object, object, Exception> GetWeakDelegateHelperWithException<TTriggerType, TTriggerContext>(MethodInfo method)
             where TTriggerType : class
         {
-            var invocationDelegate = (Action<object, object, Exception?>)Delegate.CreateDelegate(typeof(Action<object, object, Exception>), method);
+            var invocationDelegate = (Action<TTriggerType, TTriggerContext, Exception?>)Delegate.CreateDelegate(typeof(Action<TTriggerType, TTriggerContext, Exception>), method);
 
             Action<object, object, Exception?> result = (object trigger, object triggerContext, Exception? exception) => invocationDelegate((TTriggerType)trigger, (TTriggerContext)triggerContext, exception);
             return result;
diff --git a/src/EntityFrameworkCore.Triggered/TriggerSession.cs b/src/EntityFrameworkCore.Triggered/TriggerSession.cs
@@ -26,6 +26,7 @@ public class TriggerSession : ITriggerSession
         readonly EntityBagStateManager _entityBagStateManager = new();
 
         bool _raiseBeforeSaveTriggersCalled;
+        bool _raiseBeforeSaveAsyncTriggersCalled;
 
         public TriggerSession(ITriggerService triggerService, TriggerSessionConfiguration configuration, ITriggerDiscoveryService triggerDiscoveryService, TriggerContextTracker tracker, ILogger<TriggerSession> logger)
         {
@@ -207,11 +208,11 @@ public void RaiseBeforeSaveTriggers(bool skipDetectedChanges)
         }
 
         public Task RaiseBeforeSaveAsyncTriggers(CancellationToken cancellationToken)
-            => RaiseBeforeSaveAsyncTriggers(_raiseBeforeSaveTriggersCalled, cancellationToken);
+            => RaiseBeforeSaveAsyncTriggers(_raiseBeforeSaveAsyncTriggersCalled, cancellationToken);
 
         public Task RaiseBeforeSaveAsyncTriggers(bool skipDetectedChanges, CancellationToken cancellationToken)
         {
-            _raiseBeforeSaveTriggersCalled = true;
+            _raiseBeforeSaveAsyncTriggersCalled = true;
 
             ITriggerContextDiscoveryStrategy? strategy;
 
@@ -235,7 +236,7 @@ public Task RaiseBeforeSaveAsyncTriggers(bool skipDetectedChanges, CancellationT
             }
 
             _raiseBeforeSaveTriggersCalled = true;
-            return RaiseAsyncTriggers(typeof(IBeforeSaveTrigger<>), null, strategy, entityType => new BeforeSaveAsyncTriggerDescriptor(entityType), cancellationToken);
+            return RaiseAsyncTriggers(typeof(IBeforeSaveAsyncTrigger<>), null, strategy, entityType => new BeforeSaveAsyncTriggerDescriptor(entityType), cancellationToken);
         }
 
         public void RaiseBeforeSaveCompletedTriggers()
diff --git a/test/EntityFrameworkCore.Triggered.Extensions.Tests/AbstractTrigger.cs b/test/EntityFrameworkCore.Triggered.Extensions.Tests/AbstractTrigger.cs
@@ -9,6 +9,6 @@ namespace EntityFrameworkCore.Triggered.Extensions.Tests
 {
     public abstract class AbstractTrigger : IBeforeSaveTrigger<object>
     {
-        public Task BeforeSave(ITriggerContext<object> context, CancellationToken cancellationToken) => throw new NotImplementedException();
+        public void BeforeSave(ITriggerContext<object> context) => throw new NotImplementedException();
     }
 }
diff --git a/test/EntityFrameworkCore.Triggered.Extensions.Tests/ServiceCollectionExtensionsTests.cs b/test/EntityFrameworkCore.Triggered.Extensions.Tests/ServiceCollectionExtensionsTests.cs
@@ -86,7 +86,7 @@ public void AddAssemblyTriggers_WithAssembly_RegistersWithThatAssembly()
             var serviceCollection = new ServiceCollection()
                 .AddAssemblyTriggers(typeof(ServiceCollectionExtensionsTests).Assembly);
 
-            Assert.Equal(5, serviceCollection.Count);
+            Assert.Equal(8, serviceCollection.Count);
         }
 
         protected async Task SaveChanges_TriggeredAddedThroughDI_Template(Func<IServiceCollection, IServiceCollection> transform)
@@ -143,7 +143,7 @@ public void AddTrigger_Multiple_AddsRegistrationForAll(ServiceLifetime lifetime)
                 .AddTrigger<SampleTrigger>(lifetime)
                 .AddTrigger<Trigger<object>>(lifetime);
 
-            Assert.Equal(9, serviceCollection.Count);
+            Assert.Equal(15, serviceCollection.Count);
         }
 
         [Theory]
@@ -154,7 +154,7 @@ public void AddAssemblyTriggers_Multiple_AddsRegistrationForAll(ServiceLifetime
                 .AddTrigger<SampleTrigger>(lifetime)
                 .AddAssemblyTriggers(typeof(Trigger<object>).Assembly);
 
-            Assert.Equal(9, serviceCollection.Count);
+            Assert.Equal(15, serviceCollection.Count);
         }
 
         [Fact]
@@ -220,7 +220,7 @@ public void AddTrigger_WhenExplicitlyRegisteredAsAService_OnlyAddsTheTriggerType
                 .AddSingleton<SampleTrigger>()
                 .AddTrigger<SampleTrigger>();
 
-            Assert.Equal(5, serviceCollection.Count);
+            Assert.Equal(8, serviceCollection.Count);
         }
 
         [Fact]
@@ -230,7 +230,7 @@ public void AddAssemblyTriggers_WhenExplicitlyRegisteredAsAService_OnlyAddsTheTr
                 .AddSingleton<SampleTrigger>()
                 .AddAssemblyTriggers();
 
-            Assert.Equal(5, serviceCollection.Count);
+            Assert.Equal(8, serviceCollection.Count);
         }
     }
 }
diff --git a/test/EntityFrameworkCore.Triggered.Tests/Internal/Descriptors/AfterSaveAsyncTriggerDescriptorTests.cs b/test/EntityFrameworkCore.Triggered.Tests/Internal/Descriptors/AfterSaveAsyncTriggerDescriptorTests.cs
@@ -25,7 +25,7 @@ public async Task Execute_ForwardsCall()
 
             await subject.Invoke(triggerStub, new TriggerContextStub<string>(), null, default);
 
-            Assert.Single(triggerStub.AfterSaveInvocations);
+            Assert.Single(triggerStub.AfterSaveAsyncInvocations);
         }
     }
 }
diff --git a/test/EntityFrameworkCore.Triggered.Tests/Internal/Descriptors/AfterSaveFailedTriggerDescriptorTests.cs b/test/EntityFrameworkCore.Triggered.Tests/Internal/Descriptors/AfterSaveFailedTriggerDescriptorTests.cs
@@ -14,7 +14,6 @@ public class AfterSaveFailedTriggerDescriptorTests
         public void TriggerType_ReturnsConstructuredTriggerType()
         {
             var entityType = typeof(string);
-            var exception = new Exception();
             var subject = new AfterSaveFailedTriggerDescriptor(entityType);
 
             Assert.Equal(typeof(IAfterSaveFailedTrigger<string>), subject.TriggerType);
diff --git a/test/EntityFrameworkCore.Triggered.Tests/Internal/TriggerTypeDescriptorHelpersTests.cs b/test/EntityFrameworkCore.Triggered.Tests/Internal/TriggerTypeDescriptorHelpersTests.cs
@@ -8,15 +8,27 @@ namespace EntityFrameworkCore.Triggered.Tests.Internal
     public class TriggerTypeDescriptorHelpersTests
     {
         [Fact]
-        public async Task CreateWeakDelegate_WrapsTargetMethod()
+        public void CreateWeakDelegate_WrapsTargetMethod()
         {
             var triggerStub = new TriggerStub<object>();
             var triggerContextStub = new TriggerContextStub<object>();
-            var weakDelegate = TriggerTypeDescriptorHelpers.GetAsyncWeakDelegate(typeof(IBeforeSaveTrigger<object>), typeof(object), typeof(IBeforeSaveTrigger<object>).GetMethod("BeforeSave"));
+            var weakDelegate = TriggerTypeDescriptorHelpers.GetWeakDelegate(typeof(IBeforeSaveTrigger<object>), typeof(object), typeof(IBeforeSaveTrigger<object>).GetMethod("BeforeSave"));
 
-            await weakDelegate(triggerStub, triggerContextStub, default);
+            weakDelegate(triggerStub, triggerContextStub);
 
             Assert.NotEmpty(triggerStub.BeforeSaveInvocations);
         }
+
+        [Fact]
+        public async Task CreateAsyncWeakDelegate_WrapsTargetMethod()
+        {
+            var triggerStub = new TriggerStub<object>();
+            var triggerContextStub = new TriggerContextStub<object>();
+            var weakDelegate = TriggerTypeDescriptorHelpers.GetAsyncWeakDelegate(typeof(IBeforeSaveAsyncTrigger<object>), typeof(object), typeof(IBeforeSaveAsyncTrigger<object>).GetMethod("BeforeSaveAsync"));
+
+            await weakDelegate(triggerStub, triggerContextStub, default);
+
+            Assert.NotEmpty(triggerStub.BeforeSaveAsyncInvocations);
+        }
     }
 }
diff --git a/test/EntityFrameworkCore.Triggered.Tests/Stubs/TriggerStub.cs b/test/EntityFrameworkCore.Triggered.Tests/Stubs/TriggerStub.cs
@@ -44,7 +44,7 @@ public void BeforeSave(ITriggerContext<TEntity> context)
 
         public Task BeforeSaveAsync(ITriggerContext<TEntity> context, CancellationToken cancellationToken)
         {
-            BeforeSaveInvocations.Add(context);
+            BeforeSaveAsyncInvocations.Add(context);
             BeforeSaveAsyncHandler?.Invoke(context, cancellationToken);
             return Task.CompletedTask;
         }
@@ -57,7 +57,7 @@ public void AfterSave(ITriggerContext<TEntity> context)
 
         public Task AfterSaveAsync(ITriggerContext<TEntity> context, CancellationToken cancellationToken)
         {
-            AfterSaveInvocations.Add(context);
+            AfterSaveAsyncInvocations.Add(context);
             AfterSaveAsyncHandler?.Invoke(context, cancellationToken);
             return Task.CompletedTask;
         }
@@ -71,7 +71,7 @@ public void AfterSaveFailed(ITriggerContext<TEntity> context, Exception exceptio
 
         public Task AfterSaveFailedAsync(ITriggerContext<TEntity> context, Exception exception, CancellationToken cancellationToken)
         {
-            AfterSaveFailedInvocations.Add((context, exception));
+            AfterSaveFailedAsyncInvocations.Add((context, exception));
             AfterSaveFailedAsyncHandler?.Invoke(context, exception, cancellationToken);
             return Task.CompletedTask;
         }
diff --git a/test/EntityFrameworkCore.Triggered.Tests/TriggerSessionTests.cs b/test/EntityFrameworkCore.Triggered.Tests/TriggerSessionTests.cs
@@ -63,6 +63,17 @@ public void RaiseBeforeSaveTriggers_RaisesNothingOnNoChanges()
             Assert.Empty(context.TriggerStub.BeforeSaveInvocations);
         }
 
+        [Fact]
+        public async Task RaiseBeforeSaveAsyncTriggers_RaisesNothingOnNoChanges()
+        {
+            using var context = new TestDbContext();
+            var subject = CreateSubject(context);
+
+            await subject.RaiseBeforeSaveAsyncTriggers();
+
+            Assert.Empty(context.TriggerStub.BeforeSaveAsyncInvocations);
+        }
+
         [Fact]
         public void RaiseAfterSaveTriggers_RaisesNothingOnNoChanges()
         {
@@ -75,6 +86,19 @@ public void RaiseAfterSaveTriggers_RaisesNothingOnNoChanges()
             Assert.Empty(context.TriggerStub.AfterSaveInvocations);
         }
 
+
+        [Fact]
+        public async Task RaiseAfterSaveAsyncTriggers_RaisesNothingOnNoChanges()
+        {
+            using var context = new TestDbContext();
+            var subject = CreateSubject(context);
+
+            subject.DiscoverChanges();
+            await subject.RaiseAfterSaveAsyncTriggers();
+
+            Assert.Empty(context.TriggerStub.AfterSaveAsyncInvocations);
+        }
+
         [Fact]
         public void RaiseBeforeSaveTriggers_RaisesOnceOnSimpleAddition()
         {
@@ -91,6 +115,22 @@ public void RaiseBeforeSaveTriggers_RaisesOnceOnSimpleAddition()
             Assert.Equal(1, context.TriggerStub.BeforeSaveInvocations.Count);
         }
 
+        [Fact]
+        public async Task RaiseBeforeSaveAsyncTriggers_RaisesOnceOnSimpleAddition()
+        {
+            using var context = new TestDbContext();
+            var subject = CreateSubject(context);
+
+            context.TestModels.Add(new TestModel {
+                Id = 1,
+                Name = "test1"
+            });
+
+            await subject.RaiseBeforeSaveAsyncTriggers();
+
+            Assert.Equal(1, context.TriggerStub.BeforeSaveAsyncInvocations.Count);
+        }
+
         [Fact]
         public void RaiseAfterSaveTriggers_WithoutCallToRaiseBeforeSaveTriggers_Throws()
         {
@@ -105,6 +145,20 @@ public void RaiseAfterSaveTriggers_WithoutCallToRaiseBeforeSaveTriggers_Throws()
             Assert.Throws<InvalidOperationException>(() => subject.RaiseAfterSaveTriggers());
         }
 
+        [Fact]
+        public async Task RaiseAfterSaveAsyncTriggers_WithoutCallToRaiseBeforeSaveTriggers_Throws()
+        {
+            using var context = new TestDbContext();
+            var subject = CreateSubject(context);
+
+            context.TestModels.Add(new TestModel {
+                Id = 1,
+                Name = "test1"
+            });
+
+            await Assert.ThrowsAsync<InvalidOperationException>(async () => await subject.RaiseAfterSaveAsyncTriggers());
+        }
+
         [Fact]
         public void RaiseAfterSaveTriggers_RaisesOnceOnSimpleAddition()
         {
@@ -123,7 +177,24 @@ public void RaiseAfterSaveTriggers_RaisesOnceOnSimpleAddition()
         }
 
         [Fact]
-        public async Task RaiseBeforeSaveTriggers_ThrowsOnCancelledException()
+        public async Task RaiseAfterSaveAsyncTriggers_RaisesOnceOnSimpleAddition()
+        {
+            using var context = new TestDbContext();
+            var subject = CreateSubject(context);
+
+            context.TestModels.Add(new TestModel {
+                Id = 1,
+                Name = "test1"
+            });
+
+            subject.DiscoverChanges();
+            await subject.RaiseAfterSaveAsyncTriggers();
+
+            Assert.Equal(1, context.TriggerStub.AfterSaveAsyncInvocations.Count);
+        }
+
+        [Fact]
+        public async Task RaiseBeforeSaveAsyncTriggers_ThrowsOnCancelledException()
         {
             using var context = new TestDbContext();
             var subject = CreateSubject(context);
@@ -139,7 +210,7 @@ public async Task RaiseBeforeSaveTriggers_ThrowsOnCancelledException()
         }
 
         [Fact]
-        public async Task RaiseAfterSaveTriggers_ThrowsOnCancelledException()
+        public async Task RaiseAfterSaveAsyncTriggers_ThrowsOnCancelledException()
         {
             using var context = new TestDbContext();
             var subject = CreateSubject(context);
@@ -315,6 +386,24 @@ public void RaiseAfterSaveFailedTriggers_OnException_RaisesSubsequentTriggers()
             Assert.Equal(1, context.TriggerStub.AfterSaveFailedInvocations.Count);
         }
 
+
+        [Fact]
+        public async Task RaiseAfterSaveFailedAsyncTriggers_OnException_RaisesSubsequentTriggers()
+        {
+            using var context = new TestDbContext();
+            var subject = CreateSubject(context);
+
+            context.TestModels.Add(new TestModel {
+                Id = 1,
+                Name = "test1"
+            });
+
+            subject.DiscoverChanges();
+            await subject.RaiseAfterSaveFailedAsyncTriggers(new Exception());
+
+            Assert.Equal(1, context.TriggerStub.AfterSaveFailedAsyncInvocations.Count);
+        }
+
         [Fact]
         public void RaiseBeforeSaveTriggers_OnExceptionAndRecall_SkipsPreviousTriggers()
         {

Original file line number	Diff line number	Diff line change
`@@ -11,8 +11,8 @@ public sealed class AfterSaveFailedAsyncTriggerDescriptor : IAsyncTriggerTypeDes`
`11`	`11`
`12`	`12`	`public AfterSaveFailedAsyncTriggerDescriptor(Type entityType)`
`13`	`13`	`{`
`14`		`- var triggerType = typeof(IAfterSaveFailedTrigger<>).MakeGenericType(entityType);`
`15`		`- var triggerMethod = triggerType.GetMethod(nameof(IAfterSaveFailedTrigger<object>.AfterSaveFailed));`
	`14`	`+ var triggerType = typeof(IAfterSaveFailedAsyncTrigger<>).MakeGenericType(entityType);`
	`15`	`+ var triggerMethod = triggerType.GetMethod(nameof(IAfterSaveFailedAsyncTrigger<object>.AfterSaveFailedAsync));`
`16`	`16`
`17`	`17`	`_triggerType = triggerType;`
`18`	`18`	`_invocationDelegate = TriggerTypeDescriptorHelpers.GetAsyncWeakDelegateWithException(triggerType, entityType, triggerMethod!);`
Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@ public sealed class BeforeSaveAsyncTriggerDescriptor : IAsyncTriggerTypeDescript`
`12`	`12`
`13`	`13`	`public BeforeSaveAsyncTriggerDescriptor(Type entityType)`
`14`	`14`	`{`
`15`		`- var triggerType = typeof(IBeforeSaveTrigger<>).MakeGenericType(entityType);`
`16`		`- var triggerMethod = triggerType.GetMethod(nameof(IBeforeSaveTrigger<object>.BeforeSave));`
	`15`	`+ var triggerType = typeof(IBeforeSaveAsyncTrigger<>).MakeGenericType(entityType);`
	`16`	`+ var triggerMethod = triggerType.GetMethod(nameof(IBeforeSaveAsyncTrigger<object>.BeforeSaveAsync));`
`17`	`17`
`18`	`18`	`_triggerType = triggerType;`
`19`	`19`	`_invocationDelegate = TriggerTypeDescriptorHelpers.GetAsyncWeakDelegate(triggerType, entityType, triggerMethod!);`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ static Action<object, object> GetWeakDelegateHelper<TTriggerType, TTriggerContex`
`41`	`41`	`static Action<object, object, Exception> GetWeakDelegateHelperWithException<TTriggerType, TTriggerContext>(MethodInfo method)`
`42`	`42`	`where TTriggerType : class`
`43`	`43`	`{`
`44`		`- var invocationDelegate = (Action<object, object, Exception?>)Delegate.CreateDelegate(typeof(Action<object, object, Exception>), method);`
	`44`	`+ var invocationDelegate = (Action<TTriggerType, TTriggerContext, Exception?>)Delegate.CreateDelegate(typeof(Action<TTriggerType, TTriggerContext, Exception>), method);`
`45`	`45`
`46`	`46`	`Action<object, object, Exception?> result = (object trigger, object triggerContext, Exception? exception) => invocationDelegate((TTriggerType)trigger, (TTriggerContext)triggerContext, exception);`
`47`	`47`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ public class TriggerSession : ITriggerSession`
`26`	`26`	`readonly EntityBagStateManager _entityBagStateManager = new();`
`27`	`27`
`28`	`28`	`bool _raiseBeforeSaveTriggersCalled;`
	`29`	`+ bool _raiseBeforeSaveAsyncTriggersCalled;`
`29`	`30`
`30`	`31`	`public TriggerSession(ITriggerService triggerService, TriggerSessionConfiguration configuration, ITriggerDiscoveryService triggerDiscoveryService, TriggerContextTracker tracker, ILogger<TriggerSession> logger)`
`31`	`32`	`{`
`@@ -207,11 +208,11 @@ public void RaiseBeforeSaveTriggers(bool skipDetectedChanges)`
`207`	`208`	`}`
`208`	`209`
`209`	`210`	`public Task RaiseBeforeSaveAsyncTriggers(CancellationToken cancellationToken)`
`210`		`- => RaiseBeforeSaveAsyncTriggers(_raiseBeforeSaveTriggersCalled, cancellationToken);`
	`211`	`+ => RaiseBeforeSaveAsyncTriggers(_raiseBeforeSaveAsyncTriggersCalled, cancellationToken);`
`211`	`212`
`212`	`213`	`public Task RaiseBeforeSaveAsyncTriggers(bool skipDetectedChanges, CancellationToken cancellationToken)`
`213`	`214`	`{`
`214`		`- _raiseBeforeSaveTriggersCalled = true;`
	`215`	`+ _raiseBeforeSaveAsyncTriggersCalled = true;`
`215`	`216`
`216`	`217`	`ITriggerContextDiscoveryStrategy? strategy;`
`217`	`218`
`@@ -235,7 +236,7 @@ public Task RaiseBeforeSaveAsyncTriggers(bool skipDetectedChanges, CancellationT`
`235`	`236`	`}`
`236`	`237`
`237`	`238`	`_raiseBeforeSaveTriggersCalled = true;`
`238`		`- return RaiseAsyncTriggers(typeof(IBeforeSaveTrigger<>), null, strategy, entityType => new BeforeSaveAsyncTriggerDescriptor(entityType), cancellationToken);`
	`239`	`+ return RaiseAsyncTriggers(typeof(IBeforeSaveAsyncTrigger<>), null, strategy, entityType => new BeforeSaveAsyncTriggerDescriptor(entityType), cancellationToken);`
`239`	`240`	`}`
`240`	`241`
`241`	`242`	`public void RaiseBeforeSaveCompletedTriggers()`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,6 @@ namespace EntityFrameworkCore.Triggered.Extensions.Tests`
`9`	`9`	`{`
`10`	`10`	`public abstract class AbstractTrigger : IBeforeSaveTrigger<object>`
`11`	`11`	`{`
`12`		`- public Task BeforeSave(ITriggerContext<object> context, CancellationToken cancellationToken) => throw new NotImplementedException();`
	`12`	`+ public void BeforeSave(ITriggerContext<object> context) => throw new NotImplementedException();`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ public void AddAssemblyTriggers_WithAssembly_RegistersWithThatAssembly()`
`86`	`86`	`var serviceCollection = new ServiceCollection()`
`87`	`87`	`.AddAssemblyTriggers(typeof(ServiceCollectionExtensionsTests).Assembly);`
`88`	`88`
`89`		`- Assert.Equal(5, serviceCollection.Count);`
	`89`	`+ Assert.Equal(8, serviceCollection.Count);`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`protected async Task SaveChanges_TriggeredAddedThroughDI_Template(Func<IServiceCollection, IServiceCollection> transform)`
`@@ -143,7 +143,7 @@ public void AddTrigger_Multiple_AddsRegistrationForAll(ServiceLifetime lifetime)`
`143`	`143`	`.AddTrigger<SampleTrigger>(lifetime)`
`144`	`144`	`.AddTrigger<Trigger<object>>(lifetime);`
`145`	`145`
`146`		`- Assert.Equal(9, serviceCollection.Count);`
	`146`	`+ Assert.Equal(15, serviceCollection.Count);`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`[Theory]`
`@@ -154,7 +154,7 @@ public void AddAssemblyTriggers_Multiple_AddsRegistrationForAll(ServiceLifetime`
`154`	`154`	`.AddTrigger<SampleTrigger>(lifetime)`
`155`	`155`	`.AddAssemblyTriggers(typeof(Trigger<object>).Assembly);`
`156`	`156`
`157`		`- Assert.Equal(9, serviceCollection.Count);`
	`157`	`+ Assert.Equal(15, serviceCollection.Count);`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`[Fact]`
`@@ -220,7 +220,7 @@ public void AddTrigger_WhenExplicitlyRegisteredAsAService_OnlyAddsTheTriggerType`
`220`	`220`	`.AddSingleton<SampleTrigger>()`
`221`	`221`	`.AddTrigger<SampleTrigger>();`
`222`	`222`
`223`		`- Assert.Equal(5, serviceCollection.Count);`
	`223`	`+ Assert.Equal(8, serviceCollection.Count);`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`[Fact]`
`@@ -230,7 +230,7 @@ public void AddAssemblyTriggers_WhenExplicitlyRegisteredAsAService_OnlyAddsTheTr`
`230`	`230`	`.AddSingleton<SampleTrigger>()`
`231`	`231`	`.AddAssemblyTriggers();`
`232`	`232`
`233`		`- Assert.Equal(5, serviceCollection.Count);`
	`233`	`+ Assert.Equal(8, serviceCollection.Count);`
`234`	`234`	`}`
`235`	`235`	`}`
`236`	`236`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public async Task Execute_ForwardsCall()`
`25`	`25`
`26`	`26`	`await subject.Invoke(triggerStub, new TriggerContextStub<string>(), null, default);`
`27`	`27`
`28`		`- Assert.Single(triggerStub.AfterSaveInvocations);`
	`28`	`+ Assert.Single(triggerStub.AfterSaveAsyncInvocations);`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,6 @@ public class AfterSaveFailedTriggerDescriptorTests`
`14`	`14`	`public void TriggerType_ReturnsConstructuredTriggerType()`
`15`	`15`	`{`
`16`	`16`	`var entityType = typeof(string);`
`17`		`- var exception = new Exception();`
`18`	`17`	`var subject = new AfterSaveFailedTriggerDescriptor(entityType);`
`19`	`18`
`20`	`19`	`Assert.Equal(typeof(IAfterSaveFailedTrigger<string>), subject.TriggerType);`