Entity Framework实现本地数据库与外部资源深度同步方案咨询

实体模型结构 #

Invoice 实体 #

public class Invoice
{
    public string Id { get; set; }
    public string InvoiceNumber { get; set; }
    public DateTime InvoiceDate { get; set; }
    public DateTime DueDate { get; set; }
    public decimal Amount { get; set; }
    public DateTime CreatedTime { get; set; }
    public DateTime UpdatedTime { get; set; }

    public string CustomerId { get; set; }
    public virtual Customer Customer { get; set; }

    private ICollection<InvoiceLineItem> _invoiceLineItems;
    public virtual ICollection<InvoiceLineItem> InvoiceLineItems { get => _invoiceLineItems ??= new List<InvoiceLineItem>(); protected set => _invoiceLineItems = value; }
}

InvoiceLineItem 关联实体 #

public class InvoiceLineItem 
{
    public int Quantity { get; set; }
    public decimal? Amount { get; set; }
    public decimal? Price { get; set; }
    public string TaxCode { get; set; }

    public string InvoiceId { get; set; }
    public virtual Invoice Invoice { get; set; }
}

问题背景 #

首次从外部资源同步Invoice及其子项时，直接映射新增即可：

var newRecurringInvoice = _mapper.Map<Invoice>(recurringInvoiceRemote);
_dataContext.RecurringInvoices.Add(newRecurringInvoice);

但当本地已存在同Id的Invoice时，需要处理以下同步场景：

• 外部新增子项，本地需同步新增
• 外部删除子项，本地需同步删除
• 子项无变化，保持一致
• 同Id子项字段修改，本地需同步更新

现有循环同步代码如下，疑问是仅用AutoMapper映射+Update是否足够，还是需要单独处理各场景，最优实现方案是什么：

foreach (var recurringInvoiceRemote in remoteRecurringInvoices)
{
    var localRecurringInvoice = localExistingRecurringInvoices.Where(a => a.Id == recurringInvoiceRemote.Id).FirstOrDefault();
    if (localRecurringInvoice != null)
    {
        // 更新现有记录
        localRecurringInvoice = _mapper.Map<RecurringInvoiceDto, RecurringInvoice>(recurringInvoiceRemote, localRecurringInvoice);
        _dataContext.RecurringInvoices.Update(localRecurringInvoice);
    }
    else
    {
        // 添加新记录
        var newRecurringInvoice = _mapper.Map<RecurringInvoice>(recurringInvoiceRemote);
        _dataContext.RecurringInvoices.Add(newRecurringInvoice);
    }
}

现有代码的不足 #

仅用_mapper.Map(...) + Update无法完全处理所有同步场景，核心问题在于：

1. AutoMapper默认只会覆盖InvoiceLineItems集合的引用，不会对比子项差异——本地原有子项会被全部替换为外部传来的子项，但EF Core无法自动识别新增/删除操作，可能引发主键冲突或遗漏删除。
2. _dataContext.RecurringInvoices.Update(localRecurringInvoice)会将整个实体标记为Modified，未变化字段也会生成更新语句，存在性能冗余。
3. 若子项无唯一标识，AutoMapper无法匹配本地与外部子项，只能全量替换，无法处理字段更新场景。

最优实现方案 #

针对关联集合的同步，标准做法是通过唯一标识对比本地与外部子项，分别处理新增、更新、删除操作，具体步骤如下：

1. 给子项添加唯一标识 #

首先需给InvoiceLineItem添加全局唯一Id字段：

public class InvoiceLineItem 
{
    public string Id { get; set; } // 新增唯一标识
    // 其他原有字段...
}

若外部资源未提供子项Id，可暂时用组合键（如InvoiceId+TaxCode+Price），但优先要求外部提供唯一Id以保证匹配准确性。

2. 分步处理主实体与子项 #

foreach (var recurringInvoiceRemote in remoteRecurringInvoices)
{
    // 预加载本地Invoice的子项，否则无法对比差异
    var localRecurringInvoice = localExistingRecurringInvoices
        .Include(i => i.InvoiceLineItems)
        .FirstOrDefault(a => a.Id == recurringInvoiceRemote.Id);

    if (localRecurringInvoice != null)
    {
        // 1. 更新主实体字段（EF Core会自动跟踪变化，无需调用Update）
        _mapper.Map(recurringInvoiceRemote, localRecurringInvoice);

        // 2. 处理子项集合
        var localLineItems = localRecurringInvoice.InvoiceLineItems.ToList();
        var remoteLineItems = recurringInvoiceRemote.InvoiceLineItems.ToList();

        // 用子项Id构建字典，提升匹配效率
        var localLineItemDict = localLineItems.ToDictionary(li => li.Id);
        var remoteLineItemDict = remoteLineItems.ToDictionary(li => li.Id);

        // 2.1 更新或新增子项
        foreach (var remoteLineItem in remoteLineItems)
        {
            if (localLineItemDict.TryGetValue(remoteLineItem.Id, out var localLineItem))
            {
                // 子项已存在，更新字段
                _mapper.Map(remoteLineItem, localLineItem);
            }
            else
            {
                // 子项不存在，新增
                var newLineItem = _mapper.Map<InvoiceLineItem>(remoteLineItem);
                localRecurringInvoice.InvoiceLineItems.Add(newLineItem);
            }
        }

        // 2.3 删除本地存在但外部已移除的子项
        foreach (var localLineItem in localLineItems)
        {
            if (!remoteLineItemDict.ContainsKey(localLineItem.Id))
            {
                localRecurringInvoice.InvoiceLineItems.Remove(localLineItem);
                // EF Core会自动标记该子项为Deleted
            }
        }
    }
    else
    {
        // 添加新记录（包含子项）
        var newRecurringInvoice = _mapper.Map<RecurringInvoice>(recurringInvoiceRemote);
        _dataContext.RecurringInvoices.Add(newRecurringInvoice);
    }
}

// 统一保存所有变更
await _dataContext.SaveChangesAsync();

3. 优化说明 #

• 预加载子项：必须用Include加载本地子项，否则无法进行差异对比。
• 避免全量Update：EF Core的变更跟踪只会生成实际变化字段的SQL语句，性能更优。
• 字典匹配：将子项匹配时间复杂度从O(n²)降为O(n)，适合大量子项的场景。
• AutoMapper配置：确保映射配置不会意外覆盖集合引用，可通过MapperConfiguration设置PreserveReferences或自定义集合映射逻辑。

特殊场景处理 #

若外部子项无唯一Id，可使用组合字段构建匹配键：

var localLineItemDict = localLineItems.ToDictionary(li => $"{li.TaxCode}_{li.Price}_{li.Quantity}");
var remoteLineItemDict = remoteLineItems.ToDictionary(li => $"{li.TaxCode}_{li.Price}_{li.Quantity}");

但这种方式存在匹配不准确的风险，建议尽量推动外部资源提供子项唯一标识。

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