EF Core与聚合根：如何阻止子实体变更被持久化？

针对你遇到的两个核心问题——避免LineItems为null的异常，以及阻止直接修改只读列表中的LineItem并被EF持久化——下面给出具体的实践方案：

一、先解决LineItems为null的问题 #

在Order聚合根的构造函数中初始化私有集合，确保即使没有使用Include查询，LineItems也会返回空列表而非null：

public class Order
{
    // 初始化私有集合，避免null
    private readonly List<LineItem> _lineItems = new List<LineItem>();
    
    // 对外暴露只读视图
    public IReadOnlyList<LineItem> LineItems => _lineItems.AsReadOnly();

    // EF Core所需的无参构造函数（设为私有，避免外部直接实例化）
    private Order() { }

    public Order(OrderId orderId, CustomerId customerId)
    {
        OrderId = orderId;
        CustomerId = customerId;
    }

    // 聚合根提供的添加订单项方法
    public void AddLineItem(ProductId productId, int quantity, decimal unitPrice)
    {
        // 业务验证：比如禁止重复添加同一产品
        if (_lineItems.Any(li => li.ProductId == productId))
            throw new InvalidOperationException("该产品已在订单中，请勿重复添加");
        
        var newItem = new LineItem(productId, quantity, unitPrice);
        _lineItems.Add(newItem);
    }
}

二、阻止直接修改LineItem并持久化的核心方案 #

方案1：将LineItem设计为不可变值对象（推荐，DDD最佳实践） #

订单项通常属于订单的一部分，没有独立业务标识，适合设计为不可变值对象——属性只读，仅通过构造函数初始化，修改时返回新对象而非修改原有实例。这样从根本上杜绝直接篡改的可能：

public class LineItem
{
    // 所有属性设为只读
    public ProductId ProductId { get; }
    public int Quantity { get; }
    public decimal UnitPrice { get; }

    // EF Core所需的无参构造函数（私有）
    private LineItem() { }

    // 唯一的实例化入口，附带业务验证
    public LineItem(ProductId productId, int quantity, decimal unitPrice)
    {
        if (quantity <= 0)
            throw new ArgumentOutOfRangeException(nameof(quantity), "订单项数量必须大于0");
        if (unitPrice < 0)
            throw new ArgumentOutOfRangeException(nameof(unitPrice), "单价不能为负数");
        
        ProductId = productId;
        Quantity = quantity;
        UnitPrice = unitPrice;
    }

    // 如需修改，返回新的LineItem实例
    public LineItem UpdateQuantity(int newQuantity)
    {
        return new LineItem(ProductId, newQuantity, UnitPrice);
    }
}

对应Order中修改订单项的方法：

public void UpdateLineItemQuantity(ProductId productId, int newQuantity)
{
    var targetItem = _lineItems.FirstOrDefault(li => li.ProductId == productId);
    if (targetItem == null)
        throw new KeyNotFoundException("未找到对应的订单项");
    
    // 移除旧实例，添加新实例
    _lineItems.Remove(targetItem);
    _lineItems.Add(targetItem.UpdateQuantity(newQuantity));
}

这种方式下，EF只会追踪集合的添加/删除操作，无法追踪LineItem内部属性的变更（因为根本无法修改）。

方案2：配置EF Core忽略LineItem的属性变更 #

如果LineItem必须是独立实体（有自己的主键），可以在DbContext的模型配置中，让EF忽略LineItem属性的变更，仅关注集合的增删：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<LineItem>(b =>
    {
        b.HasKey(li => li.Id);
        
        // 标记属性为仅在新增时可写，后续修改不追踪
        b.Property(li => li.Quantity).IsReadOnlyBeforeSave();
        b.Property(li => li.UnitPrice).IsReadOnlyBeforeSave();
        
        // 或者更彻底：忽略所有属性的保存后变更
        foreach (var property in b.Metadata.GetProperties())
        {
            property.SetAfterSaveBehavior(PropertySaveBehavior.Ignore);
        }
    });
}

注意：这种方式会忽略所有LineItem属性的修改，包括通过聚合根方法的合法修改，因此只适合特殊场景。

方案3：自定义EF变更追踪拦截器 #

通过拦截EF的SaveChanges操作，检查LineItem的修改是否由聚合根方法触发，非法修改则抛出异常或重置状态：

public class LineItemChangeInterceptor : SaveChangesInterceptor
{
    public override ValueTask<InterceptionResult<int>> SavingChangesAsync(
        DbContextEventData eventData, 
        InterceptionResult<int> result, 
        CancellationToken cancellationToken = default)
    {
        var context = eventData.Context;
        if (context == null)
            return base.SavingChangesAsync(eventData, result, cancellationToken);

        // 找到所有被修改的LineItem
        var modifiedLineItems = context.ChangeTracker.Entries<LineItem>()
            .Where(e => e.State == EntityState.Modified)
            .ToList();

        foreach (var entry in modifiedLineItems)
        {
            // 检查该LineItem所属的Order是否有集合变更（增删操作）
            var orderEntry = entry.References
                .FirstOrDefault(r => r.TargetEntry.Entity is Order)?.TargetEntry;
            
            if (orderEntry == null || !orderEntry.Collection(o => o.LineItems).IsModified)
            {
                // 无对应Order的集合变更，说明是直接修改LineItem，抛出异常
                throw new InvalidOperationException("禁止直接修改订单项，请通过Order的聚合根方法操作");
                // 或者重置状态：entry.State = EntityState.Unchanged;
            }
        }

        return base.SavingChangesAsync(eventData, result, cancellationToken);
    }
}

在DbContext中注册拦截器：

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder.AddInterceptors(new LineItemChangeInterceptor());
}

总结 #

优先选择方案1（不可变值对象），既符合DDD聚合根的设计原则，又从根源上解决了篡改问题，同时代码简洁易维护。其他方案作为特殊场景的补充手段。

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