EF Core变更追踪器未检测到复杂属性内部状态变更的问题

我在Stack Overflow看到我的问题可能重复，但不确定我的场景是否完全匹配。

我有一个带复杂属性的实体，示例代码如下：

public class Entity
{
  public Guid Id {get;}
  public ComplexObject Complex {get;}
}

public class ComplexObject
{
  public object CurrentObject{get;}
  public IReadOnlyCollection<object> PendingObjects{get;}
}

说明：采用DDD架构，所以属性setter设为私有，据我了解EF的变更追踪器只能用快照策略存储和比较值。

问题：获取实体后，修改ComplexObject的内部状态，提交变更到数据库时，EF并未发送Complex属性的更新值——我理解是变更追踪器判定该属性没变化。

我重现问题的步骤：

• 从数据库读取实体：DbContext.Entry(entity).Property(x=>x.Complex)...OriginalValue/CurrentValue 返回空对象 {CurrentObject = null, PendingObjects = []}，符合预期。
• 执行更新操作，为CurrentObject赋值（也可为PendingObjects赋值，不影响问题）。
• 调用仓储层的Update方法，此时检查DbContext发现：DbContext.Entry(entity).Property(x=>x.Complex)...OriginalValue/CurrentValue 返回的状态均为 {CurrentObject = {...}, PendingObjects = []}，但原始值本应不同。

我试过的方案：

• 每次操作时重新设置实体的Complex属性（不可变类型方式），能解决问题，但属于临时 workaround。
• 尝试为ComplexObject实现IComparable<>, IEquatable<>或ICloneable接口，未生效；为Entity实现ICloneable，EF的快照生成逻辑也没调用这些方法。
• 看到Stack Overflow上有强制标记属性修改的方案：DbContext.Entry(entity).Property(x=>x.Complex).IsModified = true，但这不是理想方案。

我的疑问：

• 是否有文档说明EF如何从实体生成快照？
• 是否可以拦截快照生成过程，或者帮助EF检测到已知发生变化的属性？

补充信息：该复杂属性会序列化为JSON存储到Postgres数据库中。考虑过使用值比较器，但因为是同一个引用实例，似乎不适用（也可能我操作有误）。

附加代码示例：

internal abstract class AsynchronouslyUpdatedAggregate : AggregateRoot
{
    public ProcessSemaphore ProcessSemaphore { get; }

    ...

    internal void ReleaseLock<TAggregate>(AsynchronousProcess process)
        where TAggregate : AsynchronouslyUpdatedAggregate
    {
        var releaseLock = ProcessSemaphore.TryReleaseLock(process);

        if (!releaseLock.IsLockRemoved)
        {
            throw new AggregateLockedByAnotherProcess(Id, ProcessSemaphore.CurrentProcess?.Id, process.Id);
        }

        ... // 无相关逻辑，信号量已修改或抛出异常，后续无意义
    }
}

internal class ProcessSemaphore
{
    public Queue<AsynchronousProcess> PendingProcesses { get; }

    public AsynchronousProcess? CurrentProcess { get; private set; }

    ...

    public AggregateUnlockResult TryReleaseLock(AsynchronousProcess process)
    {
        if (CurrentProcess != process)
        {
            return new(false, null); // 此情况会抛出异常，不会调用SaveChanges
        }

        PendingProcesses.TryDequeue(out var newProcess);
        CurrentProcess = newProcess; // <-- 此处为确定的变更点

        return new(true, newProcess);
    }
}

internal record AsynchronousProcess(Guid Id);

测试案例（ProcessSemaphore属性未被标记为已更新）：

• 插入继承自AsynchronouslyUpdatedAggregate的实体，其ProcessSemaphore.CurrentProcess不为null。
• 调用API触发TryReleaseLock方法或抛出异常。
• 自动调用SaveChanges。

关于EF快照生成的逻辑 #

EF的快照生成逻辑是在实体被首次加载到上下文时，对实体的属性值进行浅拷贝——对于引用类型，只拷贝对象引用，不会递归复制内部状态。所以当你修改引用类型的内部属性时，EF对比快照和当前值的引用，发现是同一个对象，就判定属性未变更。官方逻辑明确，对于复杂引用类型，EF默认只跟踪引用变化，不跟踪内部状态变化。

最优解决方案推荐 #

1. 将复杂类型设计为不可变类型（推荐，符合DDD）

你之前的临时方案思路正确，进一步完善可把ProcessSemaphore设计成不可变类型——所有状态变更都返回新实例，而非修改原有实例的内部状态：

internal class ProcessSemaphore
{
    public Queue<AsynchronousProcess> PendingProcesses { get; }
    public AsynchronousProcess? CurrentProcess { get; }

    // 构造函数初始化所有属性
    public ProcessSemaphore(AsynchronousProcess? currentProcess, Queue<AsynchronousProcess> pendingProcesses)
    {
        CurrentProcess = currentProcess;
        PendingProcesses = new Queue<AsynchronousProcess>(pendingProcesses);
    }

    public (AggregateUnlockResult Result, ProcessSemaphore NewSemaphore) TryReleaseLock(AsynchronousProcess process)
    {
        if (CurrentProcess != process)
        {
            return (new AggregateUnlockResult(false, null), this);
        }

        var newPending = new Queue<AsynchronousProcess>(PendingProcesses);
        newPending.TryDequeue(out var newProcess);
        return (new AggregateUnlockResult(true, newProcess), 
                new ProcessSemaphore(newProcess, newPending));
    }
}

然后在聚合根中更新属性：

internal void ReleaseLock<TAggregate>(AsynchronousProcess process)
    where TAggregate : AsynchronouslyUpdatedAggregate
{
    var (releaseLock, newSemaphore) = ProcessSemaphore.TryReleaseLock(process);

    if (!releaseLock.IsLockRemoved)
    {
        throw new AggregateLockedByAnotherProcess(Id, ProcessSemaphore.CurrentProcess?.Id, process.Id);
    }

    // 通过私有setter或构造函数更新ProcessSemaphore属性
    ProcessSemaphore = newSemaphore;
}

这种方式完全符合DDD聚合设计原则，同时EF能自动检测到引用变化，无需额外配置。

2. 为复杂类型实现自定义值比较器

EF Core 3.0+支持为属性配置值比较器，可自定义比较逻辑检测内部状态变化，针对ProcessSemaphore的配置示例：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<YourAggregateType>()
        .Property(e => e.ProcessSemaphore)
        .HasConversion(
            // 复用原有序列化逻辑
            semaphore => JsonSerializer.Serialize(semaphore, null),
            json => JsonSerializer.Deserialize<ProcessSemaphore>(json, null))
        .Metadata.SetValueComparer(new ValueComparer<ProcessSemaphore>(
            // 相等比较：对比CurrentProcess和PendingProcesses的内容
            (s1, s2) => s1.CurrentProcess?.Id == s2.CurrentProcess?.Id 
                        && s1.PendingProcesses.SequenceEqual(s2.PendingProcesses),
            // 哈希码生成逻辑
            s => s.CurrentProcess?.Id.GetHashCode() ?? 0 ^ s.PendingProcesses.Select(p => p.Id.GetHashCode()).Aggregate(0, (a, b) => a ^ b),
            // 快照深拷贝：生成独立实例用于对比
            s => new ProcessSemaphore
            {
                CurrentProcess = s.CurrentProcess,
                PendingProcesses = new Queue<AsynchronousProcess>(s.PendingProcesses)
            }));
}

关键是快照复制逻辑要返回深拷贝实例，确保EF能通过自定义比较器检测到内部状态变化。

3. 手动触发变更检测（备选）

如果上述方案暂时无法实施，可在修改复杂类型内部状态后，手动通知EF属性已变更：

// 在ReleaseLock执行完成后调用
DbContext.Entry(aggregate).Property(x => x.ProcessSemaphore).IsModified = true;

但该方案需要侵入业务逻辑或在仓储层统一处理，长期来看不推荐。

总结 #

优先选择不可变复杂类型（符合DDD设计），其次是自定义值比较器，手动标记修改仅作为临时过渡方案。

内容的提问来源于stack exchange，提问作者dotFive