Throw if identifying foreign key is still unknown when saving changes

src/EFCore/ChangeTracking/Internal/InternalEntityEntry.cs

@@ -639,6 +639,15 @@ protected virtual void MarkShadowPropertiesNotSet([NotNull] IEntityType entityTy
             }
         }
 
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     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 MarkUnknown([NotNull] IProperty property)
+            => _stateData.FlagProperty(property.GetIndex(), PropertyFlag.Unknown, true);
+
         internal static readonly MethodInfo ReadShadowValueMethod
             = typeof(InternalEntityEntry).GetTypeInfo().GetDeclaredMethod(nameof(ReadShadowValue));
 
@@ -1286,6 +1295,13 @@ public virtual InternalEntityEntry PrepareToSave()
                                 property.Name,
                                 EntityType.DisplayName()));
                     }
+
+                    if (property.IsKey()
+                        && property.IsForeignKey()
+                        && _stateData.IsPropertyFlagged(property.GetIndex(), PropertyFlag.Unknown))
+                    {
+                        throw new InvalidOperationException(CoreStrings.UnknownKeyValue(entityType.DisplayName(), property.Name));
+                    }
                 }
             }
             else if (EntityState == EntityState.Modified)

src/EFCore/ChangeTracking/Internal/KeyPropagator.cs

@@ -71,6 +71,8 @@ public virtual InternalEntityEntry PropagateValue(InternalEntityEntry entry, IPr
                     {
                         entry[property] = value;
                     }
+
+                    entry.MarkUnknown(property);
                 }
             }
 
@@ -108,6 +110,8 @@ public virtual async Task<InternalEntityEntry> PropagateValueAsync(
                     {
                         entry[property] = value;
                     }
+
+                    entry.MarkUnknown(property);
                 }
             }
 

src/EFCore/Properties/CoreStrings.resx

@@ -322,6 +322,9 @@
   <data name="TempValuePersists" xml:space="preserve">
     <value>The property '{property}' on entity type '{entityType}' has a temporary value while attempting to change the entity's state to '{state}'. Either set a permanent value explicitly or ensure that the database is configured to generate values for this property.</value>
   </data>
+  <data name="UnknownKeyValue" xml:space="preserve">
+    <value>The value of '{entityType}.{property}' is unknown when attempting to save changes. This is because the property is also part of a foreign key for which the principal entity in the relationship is not known.</value>
+  </data>
   <data name="LogExceptionDuringQueryIteration" xml:space="preserve">
     <value>An exception occurred while iterating over the results of a query for context type '{contextType}'.{newline}{error}</value>
     <comment>Error CoreEventId.QueryIterationFailed Type string Exception</comment>

test/EFCore.Tests/ChangeTracking/ChangeTrackerTest.cs

@@ -26,6 +26,57 @@ namespace Microsoft.EntityFrameworkCore.ChangeTracking
 {
     public class ChangeTrackerTest
     {
+        [ConditionalTheory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public async Task Keys_generated_on_behalf_of_a_principal_are_not_saved(bool async)
+        {
+            using var context = new WeakHerosContext();
+
+            var entity = new Weak { Id = Guid.NewGuid() };
+
+            if (async)
+            {
+                await context.AddAsync(entity);
+            }
+            else
+            {
+                context.Add(entity);
+            }
+
+            Assert.Equal(
+                CoreStrings.UnknownKeyValue(nameof(Weak), nameof(Weak.HeroId)),
+                Assert.Throws<InvalidOperationException>(() => context.SaveChanges()).Message);
+        }
+
+        public class Hero
+        {
+            public Guid Id { get; set; }
+            public ICollection<Weak> Weaks { get; set; }
+        }
+
+        public class Weak
+        {
+            public Guid Id { get; set; }
+            public Guid HeroId { get; set; }
+
+            public Hero Hero { get; set; }
+        }
+
+        public class WeakHerosContext : DbContext
+        {
+            protected internal override void OnModelCreating(ModelBuilder modelBuilder)
+                => modelBuilder.Entity<Weak>(
+                    b =>
+                    {
+                        b.HasKey(e => new { e.Id, e.HeroId });
+                        b.HasOne(e => e.Hero).WithMany(e => e.Weaks).HasForeignKey(e => e.HeroId);
+                    });
+
+            protected internal override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+                => optionsBuilder.UseInMemoryDatabase(nameof(WeakHerosContext));
+        }
+
         [ConditionalFact]
         public void DetectChanges_is_logged()
         {