This course will be retired on June 1, 2025.

Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll

Entity Framework Basics

Preview

Start a free Courses trial
to watch this video

Sign up for Treehouse

Deleting Entities

5:02 with James Churchill

Just one CRUD operation left—deleting entities. Let's look at a couple of options for implementing the `DeleteComicBook` method.

Follow Along

To follow along commiting your changes to this course, you'll need to fork the dotnet-comic-book-gallery-model repo. Then you can clone, commit, and push your changes to your fork like this: 

git clone <your-fork>
cd dotnet-comic-book-gallery-model
git checkout tags/v5.4 -b deleting-entities

Additional Learning

Configuring Cascade Deletes

Defining relationships using the fluent API can be confusing, so don't worry if this walkthrough doesn't make complete sense the first time that you see it. With practice—and access to good documentation—you'll be able to work your way through it.

modelBuilder.Entity<ComicBookArtist>()
    .HasRequired(cba => cba.ComicBook)
    .WithMany(cb => cb.Artists)
    .HasForeignKey(cba => cba.ComicBookId)
    .WillCascadeOnDelete(false);

First, we need to get a reference to the ComicBookArtist entity in our model by making a call to the model builder's Entity method.

modelBuilder.Entity<ComicBookArtist>()

Then we can use the HasRequired method to configure the relationship between the ComicBookArtist and ComicBook entities.

.HasRequired(cba => cba.ComicBook)

By using the HasRequired method, we're making the relationship required, which makes sense in this case as a ComicBookArtist bridge entity needs to be associated with a comic book.

The HasRequired method returns an object that allows us to configure the other side of the relationship. Since a comic book can be associated with "many" artists, we'll use the WithMany method.

.WithMany(cb => cb.Artists)

Then the WithMany method returns an object that allows us to configure the dependent navigation property on the ComicBookArtist entity. This allows us to configure a foreign key property for the relationship by calling the HasForeignKey method.

.HasForeignKey(cba => cba.ComicBookId)

And finally, the HasForeignKey method returns an object that allows us to configure the cascade delete behavior.

.WillCascadeOnDelete(false);

By passing in "false" to the WillCascadeOnDelete method, we're disabling the cascade behavior for this relationship.

Now if we tried to delete a ComicBook entity from the app, we'd get a runtime exception, because a child or dependent ComicBookArtist entity has a reference to the entity that we're trying to delete. To successfully delete the ComicBook entity, we'd need to first delete any ComicBookArtist entities that are associated with that entity.

It's also possible to globally disable cascade deletes by removing the pertinent EF conventions.

modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();

Now cascade deletes would be disabled for all of our relationships. We can still override this convention of course, by defining a relationship using the fluent API and manually enabling cascade deletes.

Related Discussions

Have questions about this video? Start a discussion with the community and Treehouse staff.

Sign up

    Related Discussions

    Have questions about this video? Start a discussion with the community and Treehouse staff.

    Sign up

    Just one CRUD operation left, deleting entities. 0:00
    Let's look at a couple of options for 0:04
    implementing the DeleteComicBook method. 0:09
    The entity that we want to delete needs to be tracked by the context before we can 0:15
    remove it. 0:20
    Which is being passed a kind book ID value. 0:20
    So, just like we did when updating an entity, 0:23
    we can use the DB set fine method to retrieve the entity. 0:27
    Start with getting an instance of the context, 0:31
    using context, context equals get context, 0:37
    then retrieve the comic book, 0:43
    Comicbook comicBook = context.ComicBooks.Find(comicBookId) 0:47
    Now that the entity is being tracked by the context, 1:01
    we can remove it by calling the DB set Remove method 1:05
    context.ComicBooks.Remove(comicBook) and 1:10
    don't forget to call the Save Changes method. 1:15
    context.SaveChanges. 1:19
    If we want to avoid having to retrieve the entity from the database, 1:24
    we can create a simple stub entity. 1:28
    This works because the only property that is used to delete 1:31
    a record from the database is its ID column value let's set up the stub entity. 1:34
    Var comicBook = new 1:43
    ComicBook() { Id 1:47
    = comicBookId }. 1:52
    Then retrieve its entry from the context and set its date to deleted. 1:56
    Context.Entry(comicBook).State = 2:02
    EntityState.Deleted; Notice that 2:08
    we're not attaching the stub entity before we retrieve its entry from the context. 2:15
    When calling the context's entry method 2:21
    if the passed in entity is not in the context EF will attach it. 2:23
    And set its state to unchanged. 2:28
    Let's test our changes. 2:30
    Set a breakpoint just after the call to the Save Changes method and run the app. 2:32
    Enter 3 to view the detail for issue number three of the bones series. 2:42
    Then enter d to delete the comic book. 2:47
    Enter y to confirm the deletion. 2:51
    Now we are at break point just after the call to the Save Changes method, 2:56
    in the output window, we can see the query that was generated and 3:02
    executed press F five to continue execution. 3:06
    Now we're back at the comic book's list, and 3:12
    the comic book that we deleted, bone issue number 3, is no longer in the list. 3:15
    When the comic book entity was deleted from the database, 3:21
    what happened to its related entities? 3:24
    Child or dependent entities, 3:26
    like the comic book artist bridge entity are automatically deleted, 3:29
    if the foreign key property on the dependent entity is not nullable 3:33
    This is possible because by default, when defining relationships in EF, 3:37
    dependent entities are configured to cascade delete. 3:42
    If the foreign key is not nullable meaning that when the parent or 3:45
    principal entity is deleted the deletion cascades down to the dependent entities. 3:50
    If the foreign key property is nullable then 3:56
    EF will set the property value to null when the principle entity is deleted. 3:58
    If we want to manually specify the cascade delete behavior 4:03
    we can use the fluent API to define the relationship or 4:07
    we can globally disable cascade deletes by removing the pertinent EF conventions. 4:11
    See the teacher's notes for examples of both approaches. 4:17
    The decision as to whether or not cascade delete should be enabled 4:21
    depends on how protective you want to be of the related data. 4:25
    Often it's appropriate, not to mention convenient, to let the cascade delete 4:29
    happen, though sometimes it's appropriate, given the nature of the data, 4:33
    to be more conservative and require the user to manually delete child or 4:37
    dependent records before they're allowed to delete the parent or principal record. 4:42
    Forcing the user to confirm the deletion of the related data gives the user 4:48
    a chance to think about what they're doing before they complete the action. 4:52
    This helps reduce the risk of accidentally deleting data that shouldn't be deleted. 4:56

    You need to sign up for Treehouse in order to download course files.

    Sign up

      You need to sign up for Treehouse in order to set up Workspace

      Sign up