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

Author: koenbeuk

src/EntityFrameworkCore.Triggered.Abstractions/ITriggerSession.cs

@@ -10,12 +10,8 @@ namespace EntityFrameworkCore.Triggered
     public interface ITriggerSession
     {
         /// <summary>
-        /// Captures any pending changes in the DbContext
+        /// Discoveres any new pending changes in the DbContext
         /// </summary>
-        /// <remarks>
-        /// Some triggers, like AfterSaveTriggers need help in knowing what has changed since by the time they are raised, the DbContext should have already committed all pending changes
-        /// Normally this is done by calling RaiseBeforeSaveTriggers prior to the DbContext committing on its changes however in case that is not possible, DiscoverChanges can be used to make a snapshot
-        /// </remarks>
         void DiscoverChanges();
         /// <summary>
         /// Makes a snapshot of all changes in the DbContext and invokes BeforeSaveTriggers recursively based on the recursive settings until all changes have been processed
@@ -27,6 +23,10 @@ public interface ITriggerSession
         /// <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);
         /// <summary>
+        /// Captures and locks all discovered changes
+        /// </summary>
+        void CaptureDiscoveredChanges();
+        /// <summary>
         /// Invokes AfterSaveTriggers non-recursively. Calling this method expects that either RaiseBeforeSaveTriggers() or DiscoverChanges() has called
         /// </summary>
         /// <returns></returns>

src/EntityFrameworkCore.Triggered/Internal/AfterSaveTriggerDescriptor.cs

@@ -8,7 +8,7 @@
 
 namespace EntityFrameworkCore.Triggered.Internal
 {
-    public class AfterSaveTriggerDescriptor : ITriggerTypeDescriptor
+    public sealed class AfterSaveTriggerDescriptor : ITriggerTypeDescriptor
     {
         readonly Func<object, object, CancellationToken, Task> _invocationDelegate;
         readonly Type _triggerType;

src/EntityFrameworkCore.Triggered/Internal/BeforeSaveTriggerDescriptor.cs

@@ -8,7 +8,7 @@
 
 namespace EntityFrameworkCore.Triggered.Internal
 {
-    public class BeforeSaveTriggerDescriptor : ITriggerTypeDescriptor
+    public sealed class BeforeSaveTriggerDescriptor : ITriggerTypeDescriptor
     {
         readonly Func<object, object, CancellationToken, Task> _invocationDelegate;
         readonly Type _triggerType;

src/EntityFrameworkCore.Triggered/Internal/TriggerContextDescriptor.cs

@@ -23,7 +23,6 @@ public TriggerContextDescriptor(EntityEntry entityEntry, ChangeType changeType)
 
         }
 
-
         public ChangeType ChangeType => _changeType;
         public object Entity => _entityEntry!.Entity;
         public Type EntityType => _entityEntry!.Entity.GetType();

src/EntityFrameworkCore.Triggered/Internal/TriggerContextTracker.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using System.Security.Cryptography.X509Certificates;
 using System.Text;
 using System.Threading.Tasks;
 using EntityFrameworkCore.Triggered.Internal.RecursionStrategy;
@@ -94,6 +96,38 @@ public IEnumerable<TriggerContextDescriptor> DiscoverChanges()
             }
         }
 
+        public void CaptureChanges()
+        {
+            if (_discoveredChanges != null && _discoveredChanges.Count > 0)
+            {
+                List<TriggerContextDescriptor>? ignoreCandidates = null;
+
+                foreach (var discoveredChange in _discoveredChanges)
+                {
+                    var currentEntityEntry = _changeTracker.Context.Entry(discoveredChange.Entity);
+                    var changeType = ResolveChangeType(currentEntityEntry);
+
+                    if (changeType != discoveredChange.ChangeType)
+                    {
+                        if (ignoreCandidates == null)
+                        {
+                            ignoreCandidates = new List<TriggerContextDescriptor>();
+                        }
+
+                        ignoreCandidates.Add(discoveredChange);
+                    }
+                }
+
+                if (ignoreCandidates != null)
+                {
+                    foreach (var ignoreCandidate in ignoreCandidates)
+                    {
+                        _discoveredChanges.Remove(ignoreCandidate);
+                    }
+                }
+            }
+        }
+
         public IEnumerable<TriggerContextDescriptor>? DiscoveredChanges => _discoveredChanges;
     }
 }

src/EntityFrameworkCore.Triggered/TriggerContext.cs

@@ -12,31 +12,23 @@ public class TriggerContext<TEntity> : ITriggerContext<TEntity>
         where TEntity: class
     {
         readonly ChangeType _type;
-        readonly EntityEntry _entityEntry;
-        readonly Lazy<TEntity?> _unmodifiedEntityLazy;
-
-        TEntity? CreateUnmodified()
-        {
-            if (ChangeType == ChangeType.Added)
-            {
-                return null;
-            }
-            else
-            {
-                return (TEntity)_entityEntry.OriginalValues.ToObject();
-            }
-        }
+        readonly TEntity _entity;
+        readonly TEntity? _unmodifiedEntity;
 
 
         public TriggerContext(EntityEntry entityEntry, ChangeType changeType)
         {
             _type = changeType;
-            _entityEntry = entityEntry;
-            _unmodifiedEntityLazy = new Lazy<TEntity?>(CreateUnmodified, false);
+            _entity = (TEntity)entityEntry.Entity;
+            
+            if (changeType != ChangeType.Added)
+            {
+                _unmodifiedEntity = (TEntity)entityEntry.OriginalValues.ToObject();
+            }
         }
 
         public ChangeType ChangeType => _type;
-        public TEntity Entity => (TEntity)_entityEntry.Entity;
-        public TEntity? UnmodifiedEntity => _unmodifiedEntityLazy.Value;
+        public TEntity Entity => _entity;
+        public TEntity? UnmodifiedEntity => _unmodifiedEntity;
     }
 }

src/EntityFrameworkCore.Triggered/TriggerSession.cs

@@ -120,6 +120,11 @@ public Task RaiseBeforeSaveTriggers(bool skipDetectedChanges, CancellationToken
             return RaiseTriggers(typeof(IBeforeSaveTrigger<>), strategy, entityType => new BeforeSaveTriggerDescriptor(entityType), cancellationToken);  
         }
 
+        public void CaptureDiscoveredChanges()
+        {
+            _tracker.CaptureChanges();
+        }
+
         public Task RaiseAfterSaveTriggers(CancellationToken cancellationToken = default)
         {
             if (_afterSaveTriggerContextDiscoveryStrategy == null)

src/EntityFrameworkCore.Triggered/TriggeredDbContext.cs

@@ -58,6 +58,7 @@ public override int SaveChanges(bool acceptAllChangesOnSuccess)
             try
             {
                 _triggerSession.RaiseBeforeSaveTriggers(default).GetAwaiter().GetResult();
+                _triggerSession.CaptureDiscoveredChanges();
                 var result = base.SaveChanges(acceptAllChangesOnSuccess);
                 _triggerSession.RaiseAfterSaveTriggers(default).GetAwaiter().GetResult();
 
@@ -86,6 +87,7 @@ public override async Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess,
             {
 
                 await _triggerSession.RaiseBeforeSaveTriggers(cancellationToken).ConfigureAwait(false);
+                _triggerSession.CaptureDiscoveredChanges();
                 var result = base.SaveChanges(acceptAllChangesOnSuccess);
                 await _triggerSession.RaiseAfterSaveTriggers(cancellationToken).ConfigureAwait(false);
 

test/EntityFrameworkCore.Triggered.Tests/Internal/TriggerContextFactoryTests.cs

@@ -4,19 +4,40 @@
 using System.Text;
 using System.Threading.Tasks;
 using EntityFrameworkCore.Triggered.Internal;
+using Microsoft.EntityFrameworkCore;
 using Xunit;
 
 namespace EntityFrameworkCore.Triggered.Tests.Internal
 {
     public class TriggerContextFactoryTests
     {
+        class TestModel
+        {
+            public Guid Id { get; set; }
+            public string Name { get; set; }
+        }
+
+        class TestDbContext : DbContext
+        {
+            public DbSet<TestModel> TestModels { get; set; }
+
+            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+            {
+                base.OnConfiguring(optionsBuilder);
+
+                optionsBuilder.UseInMemoryDatabase(nameof(TriggerContextFactoryTests));
+            }
+        }
+
         [Fact]
         public void Activate_ReturnsInstance()
         {
-            var result = TriggerContextFactory<object>.Activate(null, ChangeType.Added);
+            using var dbContext = new TestDbContext();
+            var entityEntry = dbContext.Entry(new TestModel { });
+
+            var result = TriggerContextFactory<object>.Activate(entityEntry, ChangeType.Added);
 
             Assert.NotNull(result);
         }
-
     }
 }

test/EntityFrameworkCore.Triggered.Tests/Internal/TriggerContextTrackerTests.cs

@@ -98,5 +98,63 @@ public void DiscoveredChanges_MultipleCallsToDiscoverChanges_ReturnsAllChanges()
 
             Assert.Equal(2, discoveredChanges.Count());
         }
+
+        [Fact]
+        public void CaptureDiscoveredChangesAfterAdd_UnchangedEntry_RemovesDiscoveredChange()
+        {
+            using var dbContext = new TestDbContext();
+            var subject = new TriggerContextTracker(dbContext.ChangeTracker, new EntityAndTypeRecursionStrategy());
+
+            var testModel = new TestModel();
+            dbContext.Entry(testModel).State = EntityState.Added;
+
+            var disoveredChanges = subject.DiscoverChanges();
+            Assert.Single(disoveredChanges);
+            Assert.Single(subject.DiscoveredChanges);
+
+            dbContext.Entry(testModel).State = EntityState.Unchanged;
+            disoveredChanges = subject.DiscoverChanges();
+            subject.CaptureChanges();
+            Assert.Empty(subject.DiscoveredChanges);
+        }
+
+        [Fact]
+        public void CaptureDiscoveredChangesAfterAdd_DetachedEntry_RemovesDiscoveredChange()
+        {
+            using var dbContext = new TestDbContext();
+            var subject = new TriggerContextTracker(dbContext.ChangeTracker, new EntityAndTypeRecursionStrategy());
+
+            var testModel = new TestModel();
+            dbContext.Entry(testModel).State = EntityState.Added;
+
+            var disoveredChanges = subject.DiscoverChanges();
+            Assert.Single(disoveredChanges);
+            Assert.Single(subject.DiscoveredChanges);
+
+            dbContext.Entry(testModel).State = EntityState.Detached;
+            subject.CaptureChanges();
+            Assert.Empty(subject.DiscoveredChanges);
+        }
+
+        [Fact]
+        public void CaptureDiscoveredChanges_DeletedEntry_UpdatesDiscoveredChange()
+        {
+            using var dbContext = new TestDbContext();
+            var subject = new TriggerContextTracker(dbContext.ChangeTracker, new EntityAndTypeRecursionStrategy());
+
+            var testModel = new TestModel();
+            dbContext.Entry(testModel).State = EntityState.Added;
+
+            var disoveredChanges = subject.DiscoverChanges();
+            Assert.Single(disoveredChanges);
+            Assert.Single(subject.DiscoveredChanges);
+
+            dbContext.Entry(testModel).State = EntityState.Deleted;
+            disoveredChanges = subject.DiscoverChanges();
+            Assert.Equal(2, subject.DiscoveredChanges.Count());
+
+            subject.CaptureChanges();
+            Assert.Single(subject.DiscoveredChanges);
+        }
     }
 }