ASP.NET Core Web API中JsonPatch更新关联数据时EF Core重复创建数据问题

你遇到的这个问题，本质是EF Core无法识别JsonPatch传入的JobBudgetItem为已存在的实体，反而将其判定为新实体，所以才会生成副本而非更新原有记录。核心原因和解决方法如下：

问题根源拆解 #

1. 导航属性类型限制：你的Job类里用了IEnumerable<JobBudgetItem>作为导航属性，这种只读集合类型EF Core很难跟踪内部实体的变更，它需要可写的、支持变更追踪的集合类型（比如List或ICollection）。
2. 嵌套实体的追踪缺失：JsonPatch传入的JobBudgetItem对象虽然带了Id，但这个对象是全新创建的，EF Core的变更追踪系统无法将它和数据库中已加载的实体实例关联起来，自然会当成新数据插入。

具体解决方案 #

步骤一：修改导航属性类型 #

先把Job类里的集合类型改成可追踪的：

public class Job
{
    public int Id { get; set; }
    public string Name { get; set; }
    // 替换为可写的ICollection或List，初始化空集合避免空引用
    public ICollection<JobBudgetItem> JobBudgetItems { get; set; } = new List<JobBudgetItem>();
}

步骤二：控制器Patch方法中手动关联实体 #

在Web API的Patch接口里，先从数据库加载完整的Job（包含关联的JobBudgetItems），然后手动把JsonPatch操作中的嵌套实体和EF Core追踪的现有实体绑定，再执行更新：

[HttpPatch("{id}")]
public async Task<IActionResult> PatchJob(int id, [FromBody] JsonPatchDocument<Job> patchDoc)
{
    if (patchDoc == null)
        return BadRequest();

    // 加载包含关联数据的Job实体
    var job = await _context.Jobs
        .Include(j => j.JobBudgetItems)
        .FirstOrDefaultAsync(j => j.Id == id);

    if (job == null)
        return NotFound();

    // 遍历Patch操作，处理JobBudgetItems的更新
    foreach (var operation in patchDoc.Operations.ToList())
    {
        if (operation.Path.StartsWith("/JobBudgetItems/"))
        {
            var pathSegments = operation.Path.Split('/');
            // 提取集合索引和目标属性，比如/JobBudgetItems/0/Amount
            if (int.TryParse(pathSegments[2], out int itemIndex) 
                && job.JobBudgetItems.Count > itemIndex)
            {
                var existingItem = job.JobBudgetItems.ElementAt(itemIndex);
                // 根据操作类型处理属性更新，这里以replace操作为例
                if (operation.OperationType == OperationType.Replace)
                {
                    switch (pathSegments[3])
                    {
                        case "Amount":
                            existingItem.Amount = Convert.ToDecimal(operation.Value);
                            break;
                        // 其他需要更新的属性同理添加case
                    }
                    // 标记该实体为已修改
                    _context.Entry(existingItem).State = EntityState.Modified;
                }
                // 移除当前操作，避免后续ApplyTo重复处理
                patchDoc.Operations.Remove(operation);
            }
        }
    }

    // 应用剩余的Patch操作（比如更新Job的Name属性）
    patchDoc.ApplyTo(job, ModelState);

    if (!ModelState.IsValid)
        return ValidationProblem(ModelState);

    await _context.SaveChangesAsync();
    return Ok(job);
}

步骤三：用DTO中转（更优雅的方案） #

推荐使用**数据传输对象（DTO）**做中间层，让JsonPatch先更新DTO，再把DTO的变更映射回EF Core追踪的实体，这样能更精准地控制变更逻辑：

1. 定义对应DTO类：

public class JobDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<JobBudgetItemDto> JobBudgetItems { get; set; } = new List<JobBudgetItemDto>();
}

public class JobBudgetItemDto
{
    public int Id { get; set; }
    // 只保留需要更新的属性
    public decimal Amount { get; set; }
}

2. 控制器中使用DTO处理：

[HttpPatch("{id}")]
public async Task<IActionResult> PatchJob(int id, [FromBody] JsonPatchDocument<JobDto> patchDoc)
{
    if (patchDoc == null)
        return BadRequest();

    var job = await _context.Jobs
        .Include(j => j.JobBudgetItems)
        .FirstOrDefaultAsync(j => j.Id == id);

    if (job == null)
        return NotFound();

    // 将EF实体映射到DTO（可使用AutoMapper简化，也可手动映射）
    var jobDto = new JobDto
    {
        Id = job.Id,
        Name = job.Name,
        JobBudgetItems = job.JobBudgetItems.Select(i => new JobBudgetItemDto
        {
            Id = i.Id,
            Amount = i.Amount
        }).ToList()
    };

    // 应用Patch到DTO
    patchDoc.ApplyTo(jobDto, ModelState);

    if (!ModelState.IsValid)
        return ValidationProblem(ModelState);

    // 将DTO的变更映射回EF实体
    job.Name = jobDto.Name;
    foreach (var dtoItem in jobDto.JobBudgetItems)
    {
        var existingItem = job.JobBudgetItems.First(i => i.Id == dtoItem.Id);
        existingItem.Amount = dtoItem.Amount;
        _context.Entry(existingItem).State = EntityState.Modified;
    }

    await _context.SaveChangesAsync();
    return Ok(job);
}

核心原理说明 #

EF Core的变更追踪是基于实体实例的：只有操作从数据库加载的、被EF追踪的实例时，它才会记录变更。JsonPatch直接传入的嵌套实体是全新对象，EF无法识别它对应数据库中的已有记录，所以会触发插入逻辑。通过先加载完整实体，或用DTO中转再映射回追踪实例，就能让EF正确识别需要更新的对象，避免生成副本。

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