Merge branch 'master' of https://github.com/koenbeuk/EntityFrameworkCore.Triggered

koenbeuk · koenbeuk · commit 43729c030547 · 2021-09-08T19:22:22.000+08:00
diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
diff --git a/README.md b/README.md
@@ -44,6 +44,7 @@ class StudentSignupTrigger  : IBeforeSaveTrigger<Student> {
 
 class SendEmailTrigger : IAfterSaveTrigger<Email> {
     readonly IEmailService _emailService;
+    readonly ApplicationDbContext _applicationDbContext;
     public StudentTrigger (ApplicationDbContext applicationDbContext, IEmailService emailservice) {
         _applicationDbContext = applicationDbContext;
         _emailService = emailService;
diff --git a/src/EntityFrameworkCore.Triggered.Abstractions/ITriggerContext.cs b/src/EntityFrameworkCore.Triggered.Abstractions/ITriggerContext.cs
@@ -1,4 +1,6 @@
-﻿namespace EntityFrameworkCore.Triggered
+﻿using System.Collections.Generic;
+
+namespace EntityFrameworkCore.Triggered
 {
     public interface ITriggerContext<out TEntity>
         where TEntity : class
@@ -8,5 +10,10 @@ public interface ITriggerContext<out TEntity>
         TEntity Entity { get; }
 
         TEntity? UnmodifiedEntity { get; }
+
+        /// <summary>
+        /// Gets or sets a key/value collection that can be used to share data within the scope of this Entity
+        /// </summary>
+        IDictionary<object, object> Items { get; }
     }
 }
diff --git a/src/EntityFrameworkCore.Triggered/Internal/EntityStateBagManager.cs b/src/EntityFrameworkCore.Triggered/Internal/EntityStateBagManager.cs
@@ -0,0 +1,22 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace EntityFrameworkCore.Triggered.Internal
+{
+    public sealed class EntityBagStateManager
+    {
+        private readonly Dictionary<object, IDictionary<object, object>> _resolvedBags = new();
+
+        public IDictionary<object, object> GetForEntity(object entity)
+        {
+            if (!_resolvedBags.TryGetValue(entity, out var bag))
+            {
+                bag = new Dictionary<object, object>();
+                _resolvedBags.Add(entity, bag);
+            }
+
+            return bag;
+        }
+    }
+}
diff --git a/src/EntityFrameworkCore.Triggered/Internal/TriggerContextDescriptor.cs b/src/EntityFrameworkCore.Triggered/Internal/TriggerContextDescriptor.cs
@@ -6,7 +6,7 @@ namespace EntityFrameworkCore.Triggered.Internal
 {
     public readonly struct TriggerContextDescriptor
     {
-        static readonly ConcurrentDictionary<Type, Func<object, PropertyValues?, ChangeType, object>> _cachedTriggerContextFactories = new();
+        static readonly ConcurrentDictionary<Type, Func<object, PropertyValues?, ChangeType, EntityBagStateManager, object>> _cachedTriggerContextFactories = new();
 
         readonly EntityEntry _entityEntry;
         readonly ChangeType _changeType;
@@ -23,7 +23,7 @@ public TriggerContextDescriptor(EntityEntry entityEntry, ChangeType changeType)
         public object Entity => _entityEntry!.Entity;
         public Type EntityType => _entityEntry!.Entity.GetType();
 
-        public object GetTriggerContext()
+        public object GetTriggerContext(EntityBagStateManager entityBagStateManager)
         {
             var entityEntry = _entityEntry;
             var changeType = _changeType;
@@ -37,11 +37,11 @@ public object GetTriggerContext()
             var entityType = entityEntry.Entity.GetType();
 
             var triggerContextFactory = _cachedTriggerContextFactories.GetOrAdd(entityType, entityType =>
-                (Func<object, PropertyValues?, ChangeType, object>)typeof(TriggerContextFactory<>).MakeGenericType(entityType)
+                (Func<object, PropertyValues?, ChangeType, EntityBagStateManager, object >)typeof(TriggerContextFactory<>).MakeGenericType(entityType)
                     .GetMethod(nameof(TriggerContextFactory<object>.Activate))
-                    .CreateDelegate(typeof(Func<object, PropertyValues?, ChangeType, object>)));
+                    .CreateDelegate(typeof(Func<object, PropertyValues?, ChangeType, EntityBagStateManager, object>)));
 
-            return triggerContextFactory(entityEntry.Entity, originalValues, changeType);
+            return triggerContextFactory(entityEntry.Entity, originalValues, changeType, entityBagStateManager);
         }
     }
 }
diff --git a/src/EntityFrameworkCore.Triggered/Internal/TriggerContextFactory.cs b/src/EntityFrameworkCore.Triggered/Internal/TriggerContextFactory.cs
@@ -7,29 +7,32 @@ namespace EntityFrameworkCore.Triggered.Internal
     public static class TriggerContextFactory<TEntityType>
         where TEntityType : class
     {
-        readonly static Func<object, PropertyValues?, ChangeType, TriggerContext<TEntityType>> _factoryMethod = CreateFactoryMethod();
+        readonly static Func<object, PropertyValues?, ChangeType, EntityBagStateManager, TriggerContext<TEntityType>> _factoryMethod = CreateFactoryMethod();
 
-        static Func<object, PropertyValues?, ChangeType, TriggerContext<TEntityType>> CreateFactoryMethod()
+        static Func<object, PropertyValues?, ChangeType, EntityBagStateManager, TriggerContext<TEntityType>> CreateFactoryMethod()
         {
             var entityParamExpression = Expression.Parameter(typeof(object), "object");
             var originalValuesParamExpression = Expression.Parameter(typeof(PropertyValues), "originalValues");
             var changeTypeParamExpression = Expression.Parameter(typeof(ChangeType), "changeType");
+            var entityBagStateManagerExpression = Expression.Parameter(typeof(EntityBagStateManager), "entityBagStateManager");
 
-            return Expression.Lambda<Func<object, PropertyValues?, ChangeType, TriggerContext<TEntityType>>>(
+            return Expression.Lambda<Func<object, PropertyValues?, ChangeType, EntityBagStateManager, TriggerContext<TEntityType>>>(
                 Expression.New(
-                    typeof(TriggerContext<>).MakeGenericType(typeof(TEntityType)).GetConstructor(new[] { typeof(object), typeof(PropertyValues), typeof(ChangeType) }),
+                    typeof(TriggerContext<>).MakeGenericType(typeof(TEntityType)).GetConstructor(new[] { typeof(object), typeof(PropertyValues), typeof(ChangeType), typeof(EntityBagStateManager) }),
                     entityParamExpression,
                     originalValuesParamExpression,
-                    changeTypeParamExpression
+                    changeTypeParamExpression,
+                    entityBagStateManagerExpression
                 ),
                 entityParamExpression,
                 originalValuesParamExpression,
-                changeTypeParamExpression
+                changeTypeParamExpression,
+                entityBagStateManagerExpression
             )
             .Compile();
         }
 
-        public static object Activate(object entity, PropertyValues? originalValues, ChangeType changeType)
-            => _factoryMethod(entity, originalValues, changeType);
+        public static object Activate(object entity, PropertyValues? originalValues, ChangeType changeType, EntityBagStateManager entityBagStateManager)
+            => _factoryMethod(entity, originalValues, changeType, entityBagStateManager);
     }
 }
diff --git a/src/EntityFrameworkCore.Triggered/TriggerContext.cs b/src/EntityFrameworkCore.Triggered/TriggerContext.cs
@@ -1,22 +1,25 @@
-﻿using Microsoft.EntityFrameworkCore.ChangeTracking;
+﻿using System.Collections.Generic;
+using EntityFrameworkCore.Triggered.Internal;
+using Microsoft.EntityFrameworkCore.ChangeTracking;
 
 namespace EntityFrameworkCore.Triggered
 {
     public class TriggerContext<TEntity> : ITriggerContext<TEntity>
         where TEntity : class
     {
-        readonly ChangeType _type;
         readonly TEntity _entity;
+        readonly ChangeType _type;
         readonly PropertyValues? _originalValues;
+        readonly EntityBagStateManager _entityBagStateManager;
 
         TEntity? _unmodifiedEntity;
 
-
-        public TriggerContext(object entity, PropertyValues? originalValues, ChangeType changeType)
+        public TriggerContext(object entity, PropertyValues? originalValues, ChangeType changeType, EntityBagStateManager entityBagStateManager)
         {
-            _type = changeType;
             _entity = (TEntity)entity;
             _originalValues = originalValues;
+            _type = changeType;
+            _entityBagStateManager = entityBagStateManager;
         }
 
         public ChangeType ChangeType => _type;
@@ -40,5 +43,7 @@ public TEntity? UnmodifiedEntity
                 }
             }
         }
+
+        public IDictionary<object, object> Items => _entityBagStateManager.GetForEntity(_entity);
     }
 }
diff --git a/src/EntityFrameworkCore.Triggered/TriggerSession.cs b/src/EntityFrameworkCore.Triggered/TriggerSession.cs
@@ -22,6 +22,8 @@ public class TriggerSession : ITriggerSession
         readonly TriggerContextTracker _tracker;
         readonly ILogger<TriggerSession> _logger;
 
+        readonly EntityBagStateManager _entityBagStateManager = new();
+
         bool _raiseBeforeSaveTriggersCalled;
 
         public TriggerSession(ITriggerService triggerService, TriggerSessionConfiguration configuration, ITriggerDiscoveryService triggerDiscoveryService, TriggerContextTracker tracker, ILogger<TriggerSession> logger)
@@ -91,7 +93,7 @@ public async Task RaiseTriggers(Type openTriggerType, Exception? exception, ITri
                             _logger.LogInformation("Invoking trigger: {trigger} as {triggerType}", triggerDescriptor.Trigger.GetType(), triggerDescriptor.TypeDescriptor.TriggerType);
                         }
 
-                        await triggerDescriptor.Invoke(triggerContextDescriptor.GetTriggerContext(), exception, cancellationToken).ConfigureAwait(false);
+                        await triggerDescriptor.Invoke(triggerContextDescriptor.GetTriggerContext(_entityBagStateManager), exception, cancellationToken).ConfigureAwait(false);
                     }
                 }
 
diff --git a/test/EntityFrameworkCore.Triggered.IntegrationTests/EntityBags/ApplicationDbContext.cs b/test/EntityFrameworkCore.Triggered.IntegrationTests/EntityBags/ApplicationDbContext.cs
@@ -0,0 +1,18 @@
+﻿using Microsoft.EntityFrameworkCore;
+
+namespace EntityFrameworkCore.Triggered.IntegrationTests.EntityBags
+{
+    public class ApplicationDbContext
+#if EFCORETRIGGERED1
+        : TriggeredDbContext
+#else
+        : DbContext
+#endif
+    {
+        public ApplicationDbContext(DbContextOptions options) : base(options)
+        {
+        }
+
+        public DbSet<User> Users { get; set; }
+    }
+}
diff --git a/test/EntityFrameworkCore.Triggered.IntegrationTests/EntityBags/EntityBagsTestScenario.cs b/test/EntityFrameworkCore.Triggered.IntegrationTests/EntityBags/EntityBagsTestScenario.cs
@@ -0,0 +1,47 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using ScenarioTests;
+using Xunit;
+
+namespace EntityFrameworkCore.Triggered.IntegrationTests.EntityBags
+{
+    public partial class EntityBagsTestScenario
+    {
+        [Scenario(NamingPolicy = ScenarioTestMethodNamingPolicy.Test)]
+        public void PlayScenario(ScenarioContext scenario)
+        {
+            using var dbcontext = new ApplicationDbContext(
+                new DbContextOptionsBuilder()
+                    .UseInMemoryDatabase(scenario.TargetName)
+                    .UseTriggers(triggerOptions => {
+                        triggerOptions.AddTrigger<Triggers.StampModifiedOnTrigger>();
+                        triggerOptions.AddTrigger<Triggers.SoftDeleteTrigger>();
+                    })
+                    .Options
+            );
+
+            var user = new User();
+            dbcontext.Users.Add(user);
+            dbcontext.SaveChanges();
+
+            scenario.Fact("ModifiedOn is null", () => Assert.Null(user.ModifiedOn));
+            scenario.Fact("DeletedOn is null", () => Assert.Null(user.DeletedOn));
+
+            dbcontext.Remove(user);
+            dbcontext.SaveChanges();
+
+            scenario.Fact("ModifiedOn is null after removal", () => Assert.Null(user.ModifiedOn));
+            scenario.Fact("DeletedOn is not null after removal", () => Assert.NotNull(user.DeletedOn));
+
+            user.Name = "Jon";
+            dbcontext.SaveChanges();
+
+            scenario.Fact("ModifiedOn is not null after update", () => Assert.NotNull(user.ModifiedOn));
+        }
+    }
+}
diff --git a/test/EntityFrameworkCore.Triggered.IntegrationTests/EntityBags/Triggers/SoftDeleteTrigger.cs b/test/EntityFrameworkCore.Triggered.IntegrationTests/EntityBags/Triggers/SoftDeleteTrigger.cs
@@ -0,0 +1,34 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered.IntegrationTests.EntityBags.Triggers
+{
+    public class SoftDeleteTrigger : IBeforeSaveTrigger<User>
+    {
+        public const string IsSoftDeleted = "SoftDeleteTrigger_IsSoftDeleted";
+
+        readonly ApplicationDbContext _dbContext;
+
+        public SoftDeleteTrigger(ApplicationDbContext dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public Task BeforeSave(ITriggerContext<User> context, CancellationToken cancellationToken)
+        {
+            if (context.ChangeType is ChangeType.Deleted)
+            {
+                context.Items[IsSoftDeleted] = true;
+                context.Entity.DeletedOn = DateTime.UtcNow;
+
+                _dbContext.Entry(context.Entity).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
+            }
+
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/test/EntityFrameworkCore.Triggered.IntegrationTests/EntityBags/Triggers/StampModifiedOnTrigger.cs b/test/EntityFrameworkCore.Triggered.IntegrationTests/EntityBags/Triggers/StampModifiedOnTrigger.cs
@@ -0,0 +1,25 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace EntityFrameworkCore.Triggered.IntegrationTests.EntityBags.Triggers
+{
+    public class StampModifiedOnTrigger : IBeforeSaveTrigger<User>
+    {
+        public Task BeforeSave(ITriggerContext<User> context, CancellationToken cancellationToken)
+        {
+            if (context.ChangeType is ChangeType.Modified)
+            {
+                if (!context.Items.ContainsKey(SoftDeleteTrigger.IsSoftDeleted))
+                {
+                    context.Entity.ModifiedOn = DateTime.UtcNow;
+                }
+            }
+
+            return Task.CompletedTask;
+        }
+    }
+}
diff --git a/test/EntityFrameworkCore.Triggered.IntegrationTests/EntityBags/User.cs b/test/EntityFrameworkCore.Triggered.IntegrationTests/EntityBags/User.cs
@@ -0,0 +1,13 @@
+﻿using System;
+
+namespace EntityFrameworkCore.Triggered.IntegrationTests.EntityBags
+{
+    public class User
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+
+        public DateTime? ModifiedOn { get; set; }
+        public DateTime? DeletedOn { get; set; }
+    }
+}
diff --git a/test/EntityFrameworkCore.Triggered.Tests/Internal/EntityBagStateManagerTests.cs b/test/EntityFrameworkCore.Triggered.Tests/Internal/EntityBagStateManagerTests.cs
@@ -0,0 +1,38 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using EntityFrameworkCore.Triggered.Internal;
+using Xunit;
+
+namespace EntityFrameworkCore.Triggered.Tests.Internal
+{
+    public class EntityBagStateManagerTests
+    {
+        [Fact]
+        public void GetForEntity_MultipleCallsForSameEntity_ReturnsSameInstance()
+        {
+            var subject = new EntityBagStateManager();
+            var entity = new object();
+            var expectedBag = subject.GetForEntity(entity);
+
+            var bag = subject.GetForEntity(entity);
+
+            Assert.Same(expectedBag, bag);
+        }
+
+        [Fact]
+        public void GetForEntity_MultipleCallsForDifferentEntities_ReturnsDifferentInstances()
+        {
+            var subject = new EntityBagStateManager();
+            var entity1 = new object();
+            var entity2 = new object();
+
+            var entity1Bag = subject.GetForEntity(entity1);
+            var entity2Bag = subject.GetForEntity(entity2);
+
+            Assert.NotSame(entity1Bag, entity2Bag);
+        }
+    }
+}
diff --git a/test/EntityFrameworkCore.Triggered.Tests/Internal/TriggerContextFactoryTests.cs b/test/EntityFrameworkCore.Triggered.Tests/Internal/TriggerContextFactoryTests.cs
@@ -35,7 +35,7 @@ public void Activate_ReturnsInstance()
             using var dbContext = new TestDbContext();
             var entityEntry = dbContext.Entry(new TestModel { });
 
-            var result = TriggerContextFactory<object>.Activate(entityEntry, entityEntry.OriginalValues, ChangeType.Added);
+            var result = TriggerContextFactory<object>.Activate(entityEntry, entityEntry.OriginalValues, ChangeType.Added, new());
 
             Assert.NotNull(result);
         }
diff --git a/test/EntityFrameworkCore.Triggered.Tests/Stubs/TriggerContextStub.cs b/test/EntityFrameworkCore.Triggered.Tests/Stubs/TriggerContextStub.cs
diff --git a/test/EntityFrameworkCore.Triggered.Tests/TriggerContextTests.cs b/test/EntityFrameworkCore.Triggered.Tests/TriggerContextTests.cs
diff --git a/test/EntityFrameworkCore.Triggered.Transactions.Tests/Stubs/TriggerContextStub.cs b/test/EntityFrameworkCore.Triggered.Transactions.Tests/Stubs/TriggerContextStub.cs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,6 @@`
`1`		`-namespace EntityFrameworkCore.Triggered`
	`1`	`+using System.Collections.Generic;`
	`2`	`+`
	`3`	`+namespace EntityFrameworkCore.Triggered`
`2`	`4`	`{`
`3`	`5`	`public interface ITriggerContext<out TEntity>`
`4`	`6`	`where TEntity : class`
`@@ -8,5 +10,10 @@ public interface ITriggerContext<out TEntity>`
`8`	`10`	`TEntity Entity { get; }`
`9`	`11`
`10`	`12`	`TEntity? UnmodifiedEntity { get; }`
	`13`	`+`
	`14`	`+ /// <summary>`
	`15`	`+ /// Gets or sets a key/value collection that can be used to share data within the scope of this Entity`
	`16`	`+ /// </summary>`
	`17`	`+ IDictionary<object, object> Items { get; }`
`11`	`18`	`}`
`12`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace EntityFrameworkCore.Triggered.Internal`
`6`	`6`	`{`
`7`	`7`	`public readonly struct TriggerContextDescriptor`
`8`	`8`	`{`
`9`		`- static readonly ConcurrentDictionary<Type, Func<object, PropertyValues?, ChangeType, object>> _cachedTriggerContextFactories = new();`
	`9`	`+ static readonly ConcurrentDictionary<Type, Func<object, PropertyValues?, ChangeType, EntityBagStateManager, object>> _cachedTriggerContextFactories = new();`
`10`	`10`
`11`	`11`	`readonly EntityEntry _entityEntry;`
`12`	`12`	`readonly ChangeType _changeType;`
`@@ -23,7 +23,7 @@ public TriggerContextDescriptor(EntityEntry entityEntry, ChangeType changeType)`
`23`	`23`	`public object Entity => _entityEntry!.Entity;`
`24`	`24`	`public Type EntityType => _entityEntry!.Entity.GetType();`
`25`	`25`
`26`		`- public object GetTriggerContext()`
	`26`	`+ public object GetTriggerContext(EntityBagStateManager entityBagStateManager)`
`27`	`27`	`{`
`28`	`28`	`var entityEntry = _entityEntry;`
`29`	`29`	`var changeType = _changeType;`
`@@ -37,11 +37,11 @@ public object GetTriggerContext()`
`37`	`37`	`var entityType = entityEntry.Entity.GetType();`
`38`	`38`
`39`	`39`	`var triggerContextFactory = _cachedTriggerContextFactories.GetOrAdd(entityType, entityType =>`
`40`		`- (Func<object, PropertyValues?, ChangeType, object>)typeof(TriggerContextFactory<>).MakeGenericType(entityType)`
	`40`	`+ (Func<object, PropertyValues?, ChangeType, EntityBagStateManager, object >)typeof(TriggerContextFactory<>).MakeGenericType(entityType)`
`41`	`41`	`.GetMethod(nameof(TriggerContextFactory<object>.Activate))`
`42`		`- .CreateDelegate(typeof(Func<object, PropertyValues?, ChangeType, object>)));`
	`42`	`+ .CreateDelegate(typeof(Func<object, PropertyValues?, ChangeType, EntityBagStateManager, object>)));`
`43`	`43`
`44`		`- return triggerContextFactory(entityEntry.Entity, originalValues, changeType);`
	`44`	`+ return triggerContextFactory(entityEntry.Entity, originalValues, changeType, entityBagStateManager);`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,22 +1,25 @@`
`1`		`-using Microsoft.EntityFrameworkCore.ChangeTracking;`
	`1`	`+using System.Collections.Generic;`
	`2`	`+using EntityFrameworkCore.Triggered.Internal;`
	`3`	`+using Microsoft.EntityFrameworkCore.ChangeTracking;`
`2`	`4`
`3`	`5`	`namespace EntityFrameworkCore.Triggered`
`4`	`6`	`{`
`5`	`7`	`public class TriggerContext<TEntity> : ITriggerContext<TEntity>`
`6`	`8`	`where TEntity : class`
`7`	`9`	`{`
`8`		`- readonly ChangeType _type;`
`9`	`10`	`readonly TEntity _entity;`
	`11`	`+ readonly ChangeType _type;`
`10`	`12`	`readonly PropertyValues? _originalValues;`
	`13`	`+ readonly EntityBagStateManager _entityBagStateManager;`
`11`	`14`
`12`	`15`	`TEntity? _unmodifiedEntity;`
`13`	`16`
`14`		`-`
`15`		`- public TriggerContext(object entity, PropertyValues? originalValues, ChangeType changeType)`
	`17`	`+ public TriggerContext(object entity, PropertyValues? originalValues, ChangeType changeType, EntityBagStateManager entityBagStateManager)`
`16`	`18`	`{`
`17`		`- _type = changeType;`
`18`	`19`	`_entity = (TEntity)entity;`
`19`	`20`	`_originalValues = originalValues;`
	`21`	`+ _type = changeType;`
	`22`	`+ _entityBagStateManager = entityBagStateManager;`
`20`	`23`	`}`
`21`	`24`
`22`	`25`	`public ChangeType ChangeType => _type;`
`@@ -40,5 +43,7 @@ public TEntity? UnmodifiedEntity`
`40`	`43`	`}`
`41`	`44`	`}`
`42`	`45`	`}`
	`46`	`+`
	`47`	`+ public IDictionary<object, object> Items => _entityBagStateManager.GetForEntity(_entity);`
`43`	`48`	`}`
`44`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,8 @@ public class TriggerSession : ITriggerSession`
`22`	`22`	`readonly TriggerContextTracker _tracker;`
`23`	`23`	`readonly ILogger<TriggerSession> _logger;`
`24`	`24`
	`25`	`+ readonly EntityBagStateManager _entityBagStateManager = new();`
	`26`	`+`
`25`	`27`	`bool _raiseBeforeSaveTriggersCalled;`
`26`	`28`
`27`	`29`	`public TriggerSession(ITriggerService triggerService, TriggerSessionConfiguration configuration, ITriggerDiscoveryService triggerDiscoveryService, TriggerContextTracker tracker, ILogger<TriggerSession> logger)`
`@@ -91,7 +93,7 @@ public async Task RaiseTriggers(Type openTriggerType, Exception? exception, ITri`
`91`	`93`	`_logger.LogInformation("Invoking trigger: {trigger} as {triggerType}", triggerDescriptor.Trigger.GetType(), triggerDescriptor.TypeDescriptor.TriggerType);`
`92`	`94`	`}`
`93`	`95`
`94`		`- await triggerDescriptor.Invoke(triggerContextDescriptor.GetTriggerContext(), exception, cancellationToken).ConfigureAwait(false);`
	`96`	`+ await triggerDescriptor.Invoke(triggerContextDescriptor.GetTriggerContext(_entityBagStateManager), exception, cancellationToken).ConfigureAwait(false);`
`95`	`97`	`}`
`96`	`98`	`}`
`97`	`99`