Question

我正在努力解决几个基本的操作问题。

假设我有一个名为Master的课程：

public class Master
{
    public Master()
    {
        Children = new List<Child>();
    }

    public int Id { get; set; }
    public string SomeProperty { get; set; }

    [ForeignKey("SuperMasterId")]
    public SuperMaster SuperMaster { get; set; }
    public int SuperMasterId { get; set; }

    public ICollection<Child> Children { get; set; }
}

public class Child 
{
    public int Id { get; set; }
    public string SomeDescription { get; set; }
    public decimal Count{ get; set; }

    [ForeignKey("RelatedEntityId")]
    public RelatedEntity RelatedEntity { get; set; }
    public int RelatedEntityId { get; set; }

    [ForeignKey("MasterId")]
    public Master Master { get; set; }
    public int MasterId { get; set; }
}

我们有这样的控制器动作：

public async Task<OutputDto> Update(UpdateDto updateInput)
{
    // First get a real entity by Id from the repository
    // This repository method returns: 
    // Context.Masters
    //    .Include(x => x.SuperMaster)
    //    .Include(x => x.Children)
    //    .ThenInclude(x => x.RelatedEntity)
    //    .FirstOrDefault(x => x.Id == id)
    Master entity = await _masterRepository.Get(input.Id);

    // Update properties
    entity.SomeProperty = "Updated value";
    entity.SuperMaster.Id = updateInput.SuperMaster.Id;

    foreach (var child in input.Children)
    {
        if (entity.Children.All(x => x.Id != child.Id))
        {
            // This input child doesn't exist in entity.Children -- add it
            // Mapper.Map uses AutoMapper to map from the input DTO to entity
            entity.Children.Add(Mapper.Map<Child>(child));
            continue;
        }

        // The input child exists in entity.Children -- update it
        var oldChild = entity.Children.FirstOrDefault(x => x.Id == child.Id);
        if (oldChild == null)
        {
            continue;
        }

        // The mapper will also update child.RelatedEntity.Id
        Mapper.Map(child, oldChild);
    }

    foreach (var child in entity.Children.Where(x => x.Id != 0).ToList())
    {
        if (input.Children.All(x => x.Id != child.Id))
        {
            // The child doesn't exist in input anymore, mark it for deletion
            child.Id = -1;
        }
    }

    entity = await _masterRepository.UpdateAsync(entity);

    // Use AutoMapper to map from entity to DTO
    return MapToEntityDto(entity);
}

现在是存储库方法（MasterRepository）：

public async Task<Master> UpdateAsync(Master entity)
{
    var superMasterId = entity.SuperMaster.Id;

    // Make sure SuperMaster properties are updated in case the superMasterId is changed
    entity.SuperMaster = await Context.SuperMasters
        .FirstOrDefaultAsync(x => x.Id == superMasterId);

    // New and updated children, skip deleted
    foreach (var child in entity.Children.Where(x => x.Id != -1))
    {
        await _childRepo.InsertOrUpdateAsync(child);
    }

    // Handle deleted children
    foreach (var child in entity.Children.Where(x => x.Id == -1))
    {
        await _childRepo.DeleteAsync(child);
        entity.Children.Remove(child);
    }

    return entity;
}

最后，来自ChildrenRepository的相关代码：

public async Task<Child> InsertOrUpdateAsync(Child entity)
{
    if (entity.Id == 0)
    {
        return await InsertAsync(entity, parent);
    }

    var relatedId = entity.RelatedEntity.Id;
    entity.RelatedEntity = await Context.RelatedEntities
        .FirstOrDefaultAsync(x => x.Id == relatedId);

    // We have already updated child properties in the controller method 
    // and it's expected that changed entities are marked as changed in EF change tracker
    return entity;
}

public async Task<Child> InsertAsync(Child entity)
{
    var relatedId = entity.RelatedEntity.Id;
    entity.RelatedEntity = await Context.RelatedEntities
        .FirstOrDefaultAsync(x => x.Id == relatedId);

    entity = Context.Set<Child>().Add(entity).Entity;

    // We need the entity Id, hence the call to SaveChanges
    await Context.SaveChangesAsync();
    return entity;
}

Context属性实际上是DbContext，并且事务是在动作过滤器中启动的。如果操作引发异常，则操作筛选器执行回滚，如果不执行，则调用SaveChanges。

发送的输入对象如下所示：

{
  "someProperty": "Some property",
  "superMaster": {
     "name": "SuperMaster name",
     "id": 1
  },
  "children": [
  {
    "relatedEntity": {
      "name": "RelatedEntity name",
      "someOtherProp": 20,
      "id": 1
    },
    "count": 20,
    "someDescription": "Something"
  }],
  "id": 10
}

Masters表目前有一条Id为10的记录。它没有子节点。

抛出的异常是：

Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException: Database operation expected to affect 1 row(s) but actually affected 0 row(s). Data may have been modified or deleted since entities were loaded.

这里发生了什么？我认为EF应该跟踪变化，包括知道我们在内部方法中调用了SaveChanges。

编辑删除对SaveChanges的调用不会改变任何内容。另外，在观察SQL Server Profiler中发生的情况时，我找不到EF生成的任何 ~~INSERT或~~ UPDATE SQL语句。

EDIT2 调用SaveChanges时INSERT语句存在，但主实体仍然没有UPDATE语句。

Answer 1

像往常一样，将此问题发布到StackOverflow帮助我解决了这个问题。代码最初在上面的问题中看起来不像，但我在编写问题时正在修改代码。

在写这个问题之前，我花了将近一天时间试图弄清问题是什么，所以我尝试了不同的东西，比如重新创建实体实例并手动附加它们，将一些实体标记为Unchanged / Modified，使用AsNoTracking甚至完全禁用所有实体的自动更改跟踪并标记所有实体已手动添加或修改。

原来导致这个问题的代码是在那个子仓库的私有方法中，我省略了，因为我认为它不相关。但是，如果我没有忘记从中移除一些手动更改跟踪代码，这实际上是不相关的，它基本上摆弄了EF的自动更改跟踪器并导致它行为不端。

但是，多亏了StackOverflow，问题就解决了。当你与某人谈论这个问题时，你需要自己重新分析它，以便能够解释它的所有一点点，以便与你交谈的人（在这种情况下，SO社区）理解它。当您重新分析它时，您会注意到所有引起问题的小问题，然后更容易诊断问题。

所以无论如何，如果有人因为标题，谷歌搜索或w / e而被这个问题所吸引，这里有一些关键点：

如果要更新多个级别的实体，请始终在获取现有实体时调用.Include以包含所有相关的导航属性。这将使所有这些都加载到更改跟踪器中，您无需手动附加/标记。完成更新后，对SaveChanges的调用将正确保存所有更改。
当您需要更新子实体时，不要将AutoMapper用于顶级实体，尤其是在更新子级时必须实现一些额外的逻辑。
永远不要像我在设置Id到-1时尝试更新主键，或者就像我在控制器更新方法中尝试使用此行一样：

// The mapper will also update child.RelatedEntity.Id Mapper.Map(child, oldChild);
如果您需要处理已删除的项目，请更好地检测它们并存储在单独的列表中，然后为每个项目手动调用存储库删除方法，其中存储库删除方法将包含一些有关的最终附加逻辑相关实体。
如果您需要更改相关实体的主键，则需要先从关系中删除该相关实体，然后添加一个带有更新密钥的新实体。

所以这里是更新的控制器动作，省略了null和安全检查：

public async Task<OutputDto> Update(InputDto input)
{
    // First get a real entity by Id from the repository
    // This repository method returns: 
    // Context.Masters
    //    .Include(x => x.SuperMaster)
    //    .Include(x => x.Children)
    //    .ThenInclude(x => x.RelatedEntity)
    //    .FirstOrDefault(x => x.Id == id)
    Master entity = await _masterRepository.Get(input.Id);

    // Update the master entity properties manually
    entity.SomeProperty = "Updated value";

    // Prepare a list for any children with modified RelatedEntity
    var changedChildren = new List<Child>();

    foreach (var child in input.Children)
    {
        // Check to see if this is a new child item
        if (entity.Children.All(x => x.Id != child.Id))
        {
            // Map the DTO to child entity and add it to the collection
            entity.Children.Add(Mapper.Map<Child>(child));
            continue;
        }

        // Check to see if this is an existing child item
        var existingChild = entity.Children.FirstOrDefault(x => x.Id == child.Id);
        if (existingChild == null)
        {
            continue;
        }

        // Check to see if the related entity was changed
        if (existingChild.RelatedEntity.Id != child.RelatedEntity.Id)
        {
            // It was changed, add it to changedChildren list
            changedChildren.Add(existingChild);
            continue;
        }

        // It's safe to use AutoMapper to map the child entity and avoid updating properties manually, 
        // provided that it doesn't have child-items of their own
        Mapper.Map(child, existingChild);
    }

    // Find which of the child entities should be deleted
    // entity.IsTransient() is an extension method which returns true if the entity has just been added
    foreach (var child in entity.Children.Where(x => !x.IsTransient()).ToList())
    {
        if (input.Children.Any(x => x.Id == child.Id))
        {
            continue;
        }

        // We don't have this entity in the list sent by the client.
        // That means we should delete it
        await _childRepository.DeleteAsync(child);
        entity.Children.Remove(child);
    }

    // Parse children entities with modified related entities
    foreach (var child in changedChildren)
    {
        var newChild = input.Children.FirstOrDefault(x => x.Id == child.Id);

        // Delete the existing one
        await _childRepository.DeleteAsync(child);
        entity.Children.Remove(child);

        // Add the new one
        // It's OK to change the primary key here, as this one is a DTO, not a tracked entity,
        // and besides, if the keys are autogenerated by the database, we can't have anything but 0 for a new entity
        newChild.Id = 0;
        entity.Djelovi.Add(Mapper.Map<Child>(newChild)); 
    }

    // And finally, call the repository update and return the result mapped to DTO
    entity = await _repository.UpdateAsync(entity);
    return MapToEntityDto(entity);
}

Answer 2

使用此通用子标记子状态，易于使用

注意：


PromatCon：实体对象

amList：是您要添加或修改的子列表

rList：是您要删除的子列表

updatechild(objCas.ECC_Decision, PromatCon.ECC_Decision.Where(c => c.rid == objCas.rid & !objCas.ECC_Decision.Select(x => x.dcid).Contains(c.dcid)).toList())

public void updatechild<Ety>(ICollection<Ety> amList, ICollection<Ety> rList)
{
        foreach (var obj in amList)
        {
            var x = PromatCon.Entry(obj).GetDatabaseValues();
            if (x == null)
                PromatCon.Entry(obj).State = EntityState.Added;
            else
                PromatCon.Entry(obj).State = EntityState.Modified;
        }
        foreach (var obj in rList.ToList())
            PromatCon.Entry(obj).State = EntityState.Deleted;
}

PromatCon.SaveChanges()

EF Core - 在一个请求中添加/更新实体并添加/更新/删除子实体

2 个答案:

注意：