我也遇到了同样的问题，但我知道它在其他情况下也能正常工作，所以我把问题简化为:

parent.OtherRelatedItems.Clear();  //this worked OK on SaveChanges() - items were being deleted from DB
parent.ProblematicItems.Clear();   // this was causing the mentioned exception on SaveChanges()

OtherRelatedItems有一个复合主键(parentId +一些本地列)，工作正常 probleaticitems有自己的单列主键，而parentId只是一个FK。这导致了Clear()之后的异常。

我所要做的就是使ParentId成为复合PK的一部分，以表明没有父元素就不能存在子元素。我使用DB-first模型，添加PK并将parentId列标记为EntityKey(因此，我必须在DB和EF中更新它-不确定EF单独是否足够)。

仔细想想，这是一个非常优雅的区别，EF使用它来决定没有父对象的子对象是否“有意义”(在这种情况下，Clear()不会删除它们并抛出异常，除非你将ParentId设置为其他/特殊的对象)，或者-就像最初的问题一样-我们期望项一旦从父对象中删除就会删除。

您之所以会遇到这种情况，是因为组合和聚合之间存在差异。

在复合中，创建父对象时创建子对象，销毁父对象时销毁子对象。所以它的生命周期是由父节点控制的。例:一篇博客文章及其评论。如果一个帖子被删除，它的评论也应该被删除。对一篇不存在的文章发表评论是没有意义的。订单和订单项目也是如此。

在聚合中，子对象可以不考虑父对象而存在。如果父对象被销毁，子对象仍然可以存在，因为以后它可能被添加到不同的父对象。例如:播放列表和该播放列表中的歌曲之间的关系。如果播放列表被删除，歌曲不应该被删除。它们可能被添加到不同的播放列表中。

实体框架区分聚合和组合关系的方式如下:

对于复合:它期望子对象有一个复合主键(ParentID, ChildID)。这是通过设计来实现的，因为孩子的id应该在他们父母的范围内。 对于聚合:它期望子对象中的外键属性为空。

So, the reason you're having this issue is because of how you've set your primary key in your child table. It should be composite, but it's not. So, Entity Framework sees this association as aggregation, which means, when you remove or clear the child objects, it's not going to delete the child records. It'll simply remove the association and sets the corresponding foreign key column to NULL (so those child records can later be associated with a different parent). Since your column does not allow NULL, you get the exception you mentioned.

解决方案:

1-如果你有强烈的理由不想使用复合键，你需要显式地删除子对象。这可以比之前建议的解决方案更简单:

context.Children.RemoveRange(parent.Children);

2-否则，通过在你的子表上设置正确的主键，你的代码看起来会更有意义:

parent.Children.Clear();

我发现这个答案对同样的错误更有帮助。 EF似乎不喜欢它当你删除，它更喜欢删除。

您可以像这样删除附加到记录上的记录集合。

order.OrderDetails.ToList().ForEach(s => db.Entry(s).State = EntityState.Deleted);

在本例中，所有附加到订单的Detail记录的状态都设置为Delete。(准备添加回更新的详细信息，作为订单更新的一部分)

我今天遇到了这个问题，想分享我的解决方案。在我的例子中，解决方案是在从数据库中获取Parent之前删除Child项。

以前我是这样做的代码如下。然后我将得到这个问题中列出的相同错误。

var Parent = GetParent(parentId);
var children = Parent.Children;
foreach (var c in children )
{
     Context.Children.Remove(c);
}
Context.SaveChanges();

对我来说，有效的方法是先获取子项，使用parentId(外键)，然后删除这些项。然后我可以从数据库中获取父元素，在这一点上，它应该不再有任何子元素，我可以添加新的子元素。

var children = GetChildren(parentId);
foreach (var c in children )
{
     Context.Children.Remove(c);
}
Context.SaveChanges();

var Parent = GetParent(parentId);
Parent.Children = //assign new entities/items here

You should delete old child items thisParent.ChildItems one by one manually. Entity Framework doesn't do that for you. It finally cannot decide what you want to do with the old child items - if you want to throw them away or if you want to keep and assign them to other parent entities. You must tell Entity Framework your decision. But one of these two decisions you HAVE to make since the child entities cannot live alone without a reference to any parent in the database (due to the foreign key constraint). That's basically what the exception says.

Edit

如果子项目可以添加，更新和删除，我会做什么:

public void UpdateEntity(ParentItem parent)
{
    // Load original parent including the child item collection
    var originalParent = _dbContext.ParentItems
        .Where(p => p.ID == parent.ID)
        .Include(p => p.ChildItems)
        .SingleOrDefault();
    // We assume that the parent is still in the DB and don't check for null

    // Update scalar properties of parent,
    // can be omitted if we don't expect changes of the scalar properties
    var parentEntry = _dbContext.Entry(originalParent);
    parentEntry.CurrentValues.SetValues(parent);

    foreach (var childItem in parent.ChildItems)
    {
        var originalChildItem = originalParent.ChildItems
            .Where(c => c.ID == childItem.ID && c.ID != 0)
            .SingleOrDefault();
        // Is original child item with same ID in DB?
        if (originalChildItem != null)
        {
            // Yes -> Update scalar properties of child item
            var childEntry = _dbContext.Entry(originalChildItem);
            childEntry.CurrentValues.SetValues(childItem);
        }
        else
        {
            // No -> It's a new child item -> Insert
            childItem.ID = 0;
            originalParent.ChildItems.Add(childItem);
        }
    }

    // Don't consider the child items we have just added above.
    // (We need to make a copy of the list by using .ToList() because
    // _dbContext.ChildItems.Remove in this loop does not only delete
    // from the context but also from the child collection. Without making
    // the copy we would modify the collection we are just interating
    // through - which is forbidden and would lead to an exception.)
    foreach (var originalChildItem in
                 originalParent.ChildItems.Where(c => c.ID != 0).ToList())
    {
        // Are there child items in the DB which are NOT in the
        // new child item collection anymore?
        if (!parent.ChildItems.Any(c => c.ID == originalChildItem.ID))
            // Yes -> It's a deleted child item -> Delete
            _dbContext.ChildItems.Remove(originalChildItem);
    }

    _dbContext.SaveChanges();
}

注意:这不是测试。它假设子项集合的类型是ICollection。(我通常有IList，然后代码看起来有点不同。)为了保持简单，我还去掉了所有存储库抽象。

我不知道这是否是一个好的解决方案，但我相信必须按照这些思路做一些艰苦的工作，以处理导航集合中的各种更改。我也很乐意看到一种更简单的方法。

我尝试过这些方法和其他方法，但没有一个很有效。由于这是谷歌上的第一个答案，我将在这里添加我的解。

对我来说很有效的方法是在提交期间将关系排除在外，这样EF就不会搞砸了。我通过在DBContext中重新找到父对象并删除它来做到这一点。因为重新找到的对象的导航属性都是空的，所以在提交过程中会忽略子对象的关系。

var toDelete = db.Parents.Find(parentObject.ID);
db.Parents.Remove(toDelete);
db.SaveChanges();

注意，这里假设外键设置为ON DELETE CASCADE，所以当父行被删除时，子行将被数据库清除。