Fix optional complex property default values tracking

Fixes #37386

Author: Copilot

src/EFCore/ChangeTracking/Internal/ChangeDetector.cs

@@ -59,6 +59,19 @@ public virtual void PropertyChanged(IInternalEntry entry, IPropertyBase property
 
             DetectKeyChange(entry, property);
         }
+        else if (propertyBase is IComplexProperty { IsCollection: false } complexProperty)
+        {
+            // TODO: This requires notification change tracking for complex types
+            // Issue #36175
+            if (entry.EntityState is not EntityState.Deleted 
+                && setModified 
+                && entry is InternalEntryBase entryBase
+                && complexProperty.IsNullable 
+                && complexProperty.GetOriginalValueIndex() >= 0)
+            {
+                DetectComplexPropertyChange(entryBase, complexProperty);
+            }
+        }
         else if (propertyBase.GetRelationshipIndex() != -1
                  && propertyBase is INavigationBase navigation)
         {
@@ -292,11 +305,51 @@ private bool LocalDetectChanges(InternalEntryBase entry)
                     changesFound = true;
                 }
             }
+            else if (complexProperty.IsNullable && complexProperty.GetOriginalValueIndex() >= 0)
+            {
+                if (DetectComplexPropertyChange(entry, complexProperty))
+                {
+                    changesFound = true;
+                }
+            }
         }
 
         return changesFound;
     }
 
+    /// <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 bool DetectComplexPropertyChange(InternalEntryBase entry, IComplexProperty complexProperty)
+    {
+        Check.DebugAssert(!complexProperty.IsCollection, $"Expected {complexProperty.Name} to not be a collection.");
+
+        var currentValue = entry[complexProperty];
+        var originalValue = entry.GetOriginalValue(complexProperty);
+
+        if ((currentValue == null) != (originalValue == null))
+        {
+            // If it changed from null to non-null, mark all inner properties as modified
+            // to ensure the entity is detected as modified and the complex property is persisted
+            if (currentValue != null)
+            {
+                foreach (var innerProperty in complexProperty.ComplexType.GetFlattenedProperties())
+                {
+                    // Mark each property as modified. This will cause the entity state to transition to Modified.
+                    // Even if the property values are defaults, marking them as modified ensures they are persisted.
+                    entry.SetPropertyModified(innerProperty, isModified: true, changeState: true, acceptChanges: false);
+                }
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
     /// <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

test/EFCore.Specification.Tests/ComplexTypesTrackingTestBase.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.ComponentModel;
 using Microsoft.EntityFrameworkCore.ChangeTracking.Internal;
 
 namespace Microsoft.EntityFrameworkCore;
@@ -2053,10 +2054,11 @@ protected static EntityEntry<TEntity> TrackFromQuery<TEntity>(DbContext context,
     protected virtual Task ExecuteWithStrategyInTransactionAsync(
         Func<DbContext, Task> testOperation,
         Func<DbContext, Task>? nestedTestOperation1 = null,
-        Func<DbContext, Task>? nestedTestOperation2 = null)
+        Func<DbContext, Task>? nestedTestOperation2 = null,
+        Func<DbContext, Task>? nestedTestOperation3 = null)
         => TestHelpers.ExecuteWithStrategyInTransactionAsync(
             CreateContext, UseTransaction,
-            testOperation, nestedTestOperation1, nestedTestOperation2);
+            testOperation, nestedTestOperation1, nestedTestOperation2, nestedTestOperation3);
 
     protected virtual void UseTransaction(DatabaseFacade facade, IDbContextTransaction transaction)
     {
@@ -2397,6 +2399,11 @@ protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext con
                             });
                     });
             });
+
+            modelBuilder.Entity<EntityWithOptionalMultiPropComplex>(b =>
+            {
+                b.ComplexProperty(e => e.ComplexProp);
+            });
         }
     }
 
@@ -4373,4 +4380,72 @@ protected static FieldPubWithReadonlyStructCollections CreateFieldCollectionPubW
             ],
             FeaturedTeam = new TeamReadonlyStruct("Not In This Lifetime", ["Slash", "Axl"])
         };
+
+    [ConditionalTheory(), InlineData(false), InlineData(true)]
+    public virtual async Task Can_save_default_values_in_optional_complex_property_with_multiple_properties(bool async)
+    {
+        await ExecuteWithStrategyInTransactionAsync(
+            async context =>
+            {
+                var entity = Fixture.UseProxies
+                    ? context.CreateProxy<EntityWithOptionalMultiPropComplex>()
+                    : new EntityWithOptionalMultiPropComplex();
+
+                entity.Id = Guid.NewGuid();
+                entity.ComplexProp = null;
+
+                _ = async ? await context.AddAsync(entity) : context.Add(entity);
+                _ = async ? await context.SaveChangesAsync() : context.SaveChanges();
+
+                Assert.Null(entity.ComplexProp);
+            },
+            async context =>
+            {
+                var entity = async
+                    ? await context.Set<EntityWithOptionalMultiPropComplex>().SingleAsync()
+                    : context.Set<EntityWithOptionalMultiPropComplex>().Single();
+
+                Assert.Null(entity.ComplexProp);
+
+                // Set the complex property with default values
+                entity.ComplexProp = new MultiPropComplex
+                {
+                    IntValue = 0,
+                    BoolValue = false,
+                    DateValue = default
+                };
+
+                _ = async ? await context.SaveChangesAsync() : context.SaveChanges();
+
+                Assert.NotNull(entity.ComplexProp);
+                Assert.Equal(0, entity.ComplexProp.IntValue);
+                Assert.False(entity.ComplexProp.BoolValue);
+                Assert.Equal(default, entity.ComplexProp.DateValue);
+            },
+            async context =>
+            {
+                var entity = async
+                    ? await context.Set<EntityWithOptionalMultiPropComplex>().SingleAsync()
+                    : context.Set<EntityWithOptionalMultiPropComplex>().Single();
+
+                // Complex types with more than one property should materialize even with default values
+                Assert.NotNull(entity.ComplexProp);
+                Assert.Equal(0, entity.ComplexProp.IntValue);
+                Assert.False(entity.ComplexProp.BoolValue);
+                Assert.Equal(default, entity.ComplexProp.DateValue);
+            });
+    }
+
+    public class EntityWithOptionalMultiPropComplex
+    {
+        public virtual Guid Id { get; set; }
+        public virtual MultiPropComplex? ComplexProp { get; set; }
+    }
+
+    public class MultiPropComplex
+    {
+        public int IntValue { get; set; }
+        public bool BoolValue { get; set; }
+        public DateTimeOffset DateValue { get; set; }
+    }
 }

test/EFCore.SqlServer.FunctionalTests/ComplexTypesTrackingSqlServerTest.cs

@@ -338,6 +338,10 @@ public override void Can_write_original_values_for_properties_of_complex_propert
     {
     }
 
+    // Issue #36175: Complex types with notification change tracking are not supported
+    public override Task Can_save_default_values_in_optional_complex_property_with_multiple_properties(bool async)
+        => Task.CompletedTask;
+
     public class SqlServerFixture : SqlServerFixtureBase
     {
         protected override string StoreName