Generate All Possible Values Other Than PKs When Entities are Tracked…

… From Detached State

Fixes #15289

src/EFCore/ChangeTracking/Internal/IValueGenerationManager.cs

@@ -31,7 +31,7 @@ public interface IValueGenerationManager
         ///     any release. You should only use it directly in your code with extreme caution and knowing that
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
-        void Generate([NotNull] InternalEntityEntry entry);
+        void Generate([NotNull] InternalEntityEntry entry, bool includePKs = true);
 
         /// <summary>
         ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -49,6 +49,7 @@ public interface IValueGenerationManager
         /// </summary>
         Task GenerateAsync(
             [NotNull] InternalEntityEntry entry,
+            bool includePKs = true,
             CancellationToken cancellationToken = default);
 
         /// <summary>

src/EFCore/ChangeTracking/Internal/InternalEntityEntry.cs

@@ -131,9 +131,9 @@ public virtual void SetEntityState(
 
             entityState = PropagateToUnknownKey(oldState, entityState, adding, forceStateWhenUnknownKey);
 
-            if (adding)
+            if (adding || oldState is EntityState.Detached)
             {
-                StateManager.ValueGenerationManager.Generate(this);
+                StateManager.ValueGenerationManager.Generate(this, includePKs: adding);
             }
 
             SetEntityState(oldState, entityState, acceptChanges, modifyProperties);
@@ -157,9 +157,9 @@ public virtual async Task SetEntityStateAsync(
 
             entityState = PropagateToUnknownKey(oldState, entityState, adding, forceStateWhenUnknownKey);
 
-            if (adding)
+            if (adding || oldState is EntityState.Detached)
             {
-                await StateManager.ValueGenerationManager.GenerateAsync(this, cancellationToken)
+                await StateManager.ValueGenerationManager.GenerateAsync(this, includePKs: adding, cancellationToken)
                     .ConfigureAwait(false);
             }
 

src/EFCore/ChangeTracking/Internal/ValueGenerationManager.cs

@@ -79,11 +79,11 @@ public virtual InternalEntityEntry Propagate(InternalEntityEntry entry)
         ///     any release. You should only use it directly in your code with extreme caution and knowing that
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
-        public virtual void Generate(InternalEntityEntry entry)
+        public virtual void Generate(InternalEntityEntry entry, bool includePKs = true)
         {
             var entityEntry = new EntityEntry(entry);
 
-            foreach (var property in FindGeneratingProperties(entry))
+            foreach (var property in FindGeneratingProperties(entry, includePKs))
             {
                 var valueGenerator = GetValueGenerator(entry, property);
 
@@ -120,11 +120,12 @@ private void Log(InternalEntityEntry entry, IProperty property, object generated
         /// </summary>
         public virtual async Task GenerateAsync(
             InternalEntityEntry entry,
+            bool includePKs = true,
             CancellationToken cancellationToken = default)
         {
             var entityEntry = new EntityEntry(entry);
 
-            foreach (var property in FindGeneratingProperties(entry))
+            foreach (var property in FindGeneratingProperties(entry, includePKs))
             {
                 var valueGenerator = GetValueGenerator(entry, property);
                 var generatedValue = await valueGenerator.NextAsync(entityEntry, cancellationToken)
@@ -153,12 +154,14 @@ private static IEnumerable<IProperty> FindPropagatingProperties(InternalEntityEn
             }
         }
 
-        private static IEnumerable<IProperty> FindGeneratingProperties(InternalEntityEntry entry)
+        private static IEnumerable<IProperty> FindGeneratingProperties(InternalEntityEntry entry, bool includePKs = true)
         {
             foreach (var property in ((EntityType)entry.EntityType).GetProperties())
             {
                 if (property.RequiresValueGenerator()
-                    && entry.HasDefaultValue(property))
+                    && entry.HasDefaultValue(property)
+                    && (includePKs
+                        || !property.IsPrimaryKey()))
                 {
                     yield return property;
                 }

test/EFCore.Cosmos.FunctionalTests/Internal/IdentifierShadowValuePresenceTest.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.TestUtilities;
+using Xunit;
+
+namespace Microsoft.EntityFrameworkCore.Internal
+{
+    public class IdentifierShadowValuePresenceTest
+    {
+        [ConditionalFact]
+        public async Task Entities_with_null_PK_can_be_added_with_normal_use_of_DbContext_methods_and_have_id_shadow_value_and_PK_created()
+        {
+            await using var testDatabase = CosmosTestStore.Create("IdentifierShadowValuePresenceTest");
+            using var context = new IdentifierShadowValuePresenceTestContext(testDatabase);
+
+            var item = new GItem { };
+
+            Assert.Null(item.Id);
+
+            var entry = context.Add(item);
+
+            var id = entry.Property("__id").CurrentValue;
+
+            Assert.NotNull(item.Id);
+            Assert.NotNull(id);
+
+            Assert.Equal($"GItem|{item.Id}", id);
+            Assert.Equal(EntityState.Added, entry.State);
+        }
+
+        [ConditionalFact]
+        public async Task Entities_can_be_tracked_with_normal_use_of_DbContext_methods_and_have_correct_resultant_state_and_id_shadow_value()
+        {
+            await using var testDatabase = CosmosTestStore.Create("IdentifierShadowValuePresenceTest");
+            using var context = new IdentifierShadowValuePresenceTestContext(testDatabase);
+
+            var item = new Item { Id = 1337 };
+            var entry = context.Attach(item);
+
+            Assert.Equal($"Item|{item.Id}", entry.Property("__id").CurrentValue);
+            Assert.Equal(EntityState.Unchanged, entry.State);
+
+            entry.State = EntityState.Detached;
+            entry = context.Update(item = new Item { Id = 71 });
+
+            Assert.Equal($"Item|{item.Id}", entry.Property("__id").CurrentValue);
+            Assert.Equal(EntityState.Modified, entry.State);
+
+            entry.State = EntityState.Detached;
+            entry = context.Remove(item = new Item { Id = 33 });
+
+            Assert.Equal($"Item|{item.Id}", entry.Property("__id").CurrentValue);
+            Assert.Equal(EntityState.Deleted, entry.State);
+        }
+    }
+
+    public class IdentifierShadowValuePresenceTestContext : DbContext
+    {
+        private readonly string _connectionUri;
+        private readonly string _authToken;
+        private readonly string _name;
+
+        public IdentifierShadowValuePresenceTestContext(CosmosTestStore testStore)
+        {
+            _connectionUri = testStore.ConnectionUri;
+            _authToken = testStore.AuthToken;
+            _name = testStore.Name;
+        }
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            optionsBuilder
+                .UseCosmos(
+                    _connectionUri,
+                    _authToken,
+                    _name,
+                    b => b.ApplyConfiguration());
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+        }
+
+        public DbSet<GItem> GItems { get; set; }
+
+        public DbSet<Item> Items { get; set; }
+    }
+
+    public class GItem
+    {
+        public Guid? Id { get; set; }
+    }
+
+    public class Item
+    {
+        public int Id { get; set; }
+    }
+}