Remove an item from Collection using Entity Framework

I've seen a lot of people reporting this issue. It's actually quite simple to fix but makes me think there is not enough documentation on how EF is expected to behave in this situation.

Trick: When setting up the relationship between Parent and Child, you'll HAVE TO create a "composite" key on the child. This way, when you tell the Parent to delete 1 or all of its children, the related records will actually be deleted from the database.

To configure composite key using Fluent API:

modelBuilder.Entity<Child>.HasKey(t => new { t.ParentId, t.ChildId });

Then, to delete the related children:

var parent = _context.Parents.SingleOrDefault(p => p.ParentId == parentId);

var childToRemove = parent.Children.First(); // Change the logic 
parent.Children.Remove(childToRemove);

// or, you can delete all children 
// parent.Children.Clear();

_context.SaveChanges();

Done!

Here is pair of related solutions:

Delete Dependent Entities When Removed From EF Collection

I've seen 3 approaches to workaround this deficiency in EF:

1. Configure a composite key (as per Mosh's answer)
2. Raise a domain event and instruct EF to perform the child deletions in its handler (as per this answer)
3. Override DbContext's SaveChanges() and handle the deletion there (as per Euphoric's answer)

I like option 3 the best because it doesn't require modification to your database structure (1) or your domain model (2), but puts the workaround in the component (EF) that had the deficiency in the first place.

So this is an updated solution taken from Euphoric's answer/blog post:

public class MyDbContext : DbContext
{
    //... typical DbContext stuff

    public DbSet<Product> ProductSet { get; set; }
    public DbSet<Comment> CommentSet { get; set; }

    //... typical DbContext stuff


    public override int SaveChanges()
    {
        MonitorForAnyOrphanedCommentsAndDeleteThemIfRequired();
        return base.SaveChanges();
    }

    public override Task<int> SaveChangesAsync()
    {
        MonitorForAnyOrphanedCommentsAndDeleteThemIfRequired();
        return base.SaveChangesAsync();
    }

    public override Task<int> SaveChangesAsync(CancellationToken cancellationToken)
    {
        MonitorForAnyOrphanedCommentsAndDeleteThemIfRequired();
        return base.SaveChangesAsync(cancellationToken);
    }

    private void MonitorForAnyOrphanedCommentsAndDeleteThemIfRequired()
    {
        var orphans = ChangeTracker.Entries().Where(e =>
            e.Entity is Comment
            && (e.State == EntityState.Modified || e.State == EntityState.Added)
            && (e.Entity as Comment).ParentProduct == null);

        foreach (var item in orphans)
            CommentSet.Remove(item.Entity as Comment);
    }
}

Note: this assumes that ParentProduct is the navigation property on Comment back to its owning Product.

Deleting the Comment from the Product using your approach only deletes the association between Product and Comment. So that the Comment still exists.

What you need to do is to tell the ObjectContext that the Comment is also deleted using the method DeleteObject().

The way i do it is that i use the Update method of my repository (knows Entity Framework) to check for deleted associations and to also delete the obsolete entities. You can do this by using the ObjectStateManager of the ObjectContext.

public void UpdateProduct(Product product) {
  var modifiedStateEntries = Context.ObjectStateManager.GetObjectStateEntries(EntityState.Modified);
    foreach (var entry in modifiedStateEntries) {
      var comment = entry.Entity as Comment;
      if (comment != null && comment.Product == null) {
        Context.DeleteObject(comment);
      }
    }
 }

Sample:

public void RemoveComment(Guid productId, Guid commentId) {
  Product product = _productsRepository.First(p => p.Id == productId);
  Comment comment = product.Comments.First(p => p.Id == commentId);
  product.DeleteComment(comment);

  _productsRepository.Update(product);

  _uow.Commit();
}

I have solved the same problem by creating an parent attribute for my models and checking the attribute in the SaveChanges function. I have written a blog about this: http://wimpool.nl/blog/DotNet/extending-entity-framework-4-with-parentvalidator