Fix NullReferenceException when accessing null complex properties in TPH with shared columns

src/EFCore/ChangeTracking/Internal/InternalEntryBase.cs

@@ -1477,7 +1477,9 @@ public virtual void AcceptChanges()
                 var storeGeneratedIndex = property.GetStoreGeneratedIndex();
                 if (storeGeneratedIndex != -1
                     && _stateData.IsPropertyFlagged(property.GetIndex(), PropertyFlag.IsStoreGenerated)
-                    && _storeGeneratedValues.TryGetValue(storeGeneratedIndex, out var value))
+                    && _storeGeneratedValues.TryGetValue(storeGeneratedIndex, out var value)
+                    && (property.DeclaringType is not IComplexType complexType
+                        || GetCurrentValue(complexType.ComplexProperty) != null))
                 {
                     this[property] = value;
                 }

src/EFCore/Metadata/Internal/PropertyAccessorsFactory.cs

@@ -302,8 +302,18 @@ public static Expression CreateMemberAccess(
                     break;
             }
         }
-        else
+        else if (!fromDeclaringType
+                 || !addNullCheck
+                 || property?.DeclaringType is not IRuntimeComplexType declaringComplexType
+                 || instanceExpression.Type.IsValueType
+                 || declaringComplexType.ClrType.IsValueType)
         {
+            // Disable null check for all cases except:
+            // - fromDeclaringType is true AND
+            // - addNullCheck is true AND  
+            // - property is declared in a complex type AND
+            // - instance is a reference type AND
+            // - declaring complex type is a reference type
             addNullCheck = false;
         }
 

test/EFCore.SqlServer.FunctionalTests/ComplexTypesTrackingSqlServerTest.cs

@@ -8,13 +8,102 @@ public class ComplexTypesTrackingSqlServerTest(
     ITestOutputHelper testOutputHelper)
     : ComplexTypesTrackingSqlServerTestBase<ComplexTypesTrackingSqlServerTest.SqlServerFixture>(fixture, testOutputHelper)
 {
+    [ConditionalFact]
+    public virtual async Task Can_read_original_values_with_TPH_shared_complex_property_column_null()
+    {
+        await using var context = CreateContext();
+
+        await context.Database.CreateExecutionStrategy().ExecuteAsync(
+            context,
+            async context =>
+            {
+                await using var transaction = await context.Database.BeginTransactionAsync();
+
+                context.Add(new InheritedItem1 { Name = "Item1" });
+                await context.SaveChangesAsync();
+
+                context.ChangeTracker.Clear();
+                var item = await context.Set<InheritedItemBase>().Where(i => i.Name == "Item1").FirstAsync();
+                var entry = context.ChangeTracker.Entries().First();
+                var originalItem = (InheritedItemBase)entry.OriginalValues.ToObject();
+
+                Assert.NotNull(originalItem);
+                Assert.Equal("Item1", originalItem.Name);
+            });
+    }
+
+    [ConditionalFact]
+    public virtual async Task Can_read_original_values_with_TPH_shared_complex_property_column_with_value()
+    {
+        await using var context = CreateContext();
+
+        await context.Database.CreateExecutionStrategy().ExecuteAsync(
+            context,
+            async context =>
+            {
+                await using var transaction = await context.Database.BeginTransactionAsync();
+
+                context.Add(new InheritedItem1 { Name = "Item1", SharedPrice = new SharedPrice { Amount = "10.99" } });
+                await context.SaveChangesAsync();
+
+                context.ChangeTracker.Clear();
+                var item = await context.Set<InheritedItem1>().Where(i => i.Name == "Item1").FirstAsync();
+                var entry = context.ChangeTracker.Entries().First();
+                var originalItem = (InheritedItemBase)entry.OriginalValues.ToObject();
+
+                Assert.NotNull(originalItem);
+                Assert.Equal("Item1", originalItem.Name);
+                var item1 = Assert.IsType<InheritedItem1>(originalItem);
+                Assert.NotNull(item1.SharedPrice);
+                Assert.Equal("10.99", item1.SharedPrice.Amount);
+            });
+    }
+
     public class SqlServerFixture : SqlServerFixtureBase
     {
         protected override string StoreName
             => nameof(ComplexTypesTrackingSqlServerTest);
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext context)
+        {
+            base.OnModelCreating(modelBuilder, context);
+
+            modelBuilder.Entity<InheritedItemBase>().HasDiscriminator<string>("Discriminator")
+                .HasValue<InheritedItem1>("Item1")
+                .HasValue<InheritedItem2>("Item2");
+
+            modelBuilder.Entity<InheritedItem1>().ComplexProperty(
+                x => x.SharedPrice,
+                p => p.Property(a => a.Amount).HasColumnName("SharedPriceAmount"));
+
+            modelBuilder.Entity<InheritedItem2>().ComplexProperty(
+                x => x.SharedPrice,
+                p => p.Property(a => a.Amount).HasColumnName("SharedPriceAmount"));
+        }
     }
 }
 
+public abstract class InheritedItemBase
+{
+    public int Id { get; set; }
+    public required string Name { get; set; }
+}
+
+public class InheritedItem1 : InheritedItemBase
+{
+    public SharedPrice? SharedPrice { get; set; }
+}
+
+public class InheritedItem2 : InheritedItemBase
+{
+    public SharedPrice? SharedPrice { get; set; }
+}
+
+public class SharedPrice
+{
+    public required string Amount { get; init; }
+}
+
 public class ComplexTypesTrackingProxiesSqlServerTest(
     ComplexTypesTrackingProxiesSqlServerTest.SqlServerFixture fixture,
     ITestOutputHelper testOutputHelper)