Before we see how to update the Comic Books Controller to handle deletes,

let's review my solution for implementing the ValidateComicBook method.

To review, the ValidateComicBook method, which is called from both the add and

edit post action methods, needs to be updated with a query

that checks if the provided issue number is already in use or not.

To do that, we need to write a query that checks if the database contains

a different Comic Book that is associated with the same Series, and

has the same Issue Number.

Whenever I need to check for the existence of a record or

entity in the database without actually returning the entity,

itself, I typically use the Any link operator,

which will return true if an entity is found that matches our provided criteria.

For the predicate, I'm looking for a comic book whose ID property value

doesn't equal the Passed In comic book;s ID property value.

But whose Series ID and

Issue Number properties are equal to the Passed In Comic Book's property values.

This query will return true if a comic book other than the Passed In comic book

is found that it's associated with the same series and has the same issue number.

Let's test the validation method and see if it behaves as expected.

Let's try adding another Comic Book for

the Series, Bone with an Issue Number of four.

And select Jeff Smith for the Artist and Script for the Role.

Click the Save button and we get an error message.

The provided Issue Number has already been entered for the selected Series.

Okay, so far, so good.

Let's change the Issue Number to five and try saving again.

And this time, the Comic Book was successfully added.

Now, let's make sure that we can edit the Comic Book without

getting a false positive or an existing Issue Number.

Set an Average Rating value and click the Save button.

And here's our updated Comic Book.

Great, now, we have Comic Book Creates and

Updates, including the server side validation fully implemented.

Now, let's turn our attention to implementing the letter d in crud deletes.

There are two action methods that we need to update.

The Delete Get action method And

the Delete Post action method.

The Delete Get action methods only parameter is a knowable

integer-named id like the detail and adequate action methods.

If the id parameter is null,

we immediately return a BadRequest HttpStatusCode.

Otherwise, we attempt to retrieve the comicBook from

the database with the related Series eagerly loaded.

And we return a NotFound HTTP Status Code if we don't find a comicBook.

Then, we call the View method, passing in the comicBook instance.

The query to retrieve the comic book can use the link, Where operator

in order to retrieve the comicBook with a Passed In ID parameter value,

followed by a call to the SingleOrDefault method to execute the query.

Don't forget the call to the Include operator in order to eagerly load

the related Series.

_context.ComicBooks.Include(cb =>

cb.Series).Where(cb =>

cb.Id == id).SingleOrDefault().

The Delete Post action method is pretty straight forward.

It accepts an id parameter value which is used to delete the comicBook.

Then, we set the message key in the TempData dictionary and

re-direct the user to the Index action, which is our web apps home page.

To delete the comic book from the database,

we can create a comic book entity using the id parameter value that we're passed.

Attach it to the context using the entry method.

And set its entry state to deleted.

And call the context's save changes method in order to perform the deletion in

the database.

var comicBook = new ComicBook().

And set { Id = id};.

Then, _context.Entry (comicBook).State

= EntityState.Deleted.

And finally, _context.SaveChanges();.

Let's test our changes To delete a comic book, you

first need to view the Comic Book Detail page of the comic book you want to delete.

I'll click the Detail button on Issue Number five of the Bone Series.

Then, on the Comic Book Detail page, click the Delete button.

We're presented with Delete Comic Book page to confirm the deletion.

You can click the Cancel button to return to the Detail page, but I'll go ahead and

click the Delete button to delete the comic book.

We're then redirected to the Comic Books page

which displays a message confirming the comic book deletion.

We can also see that Issue Number 5 of the Bone Series

is no longer in the list of Comic Books.

With those changes completed, we can now create, update, and delete comic books.

Nice work making progress on our web app.

It's worth nothing that our approach for deleting a comic book

relies upon cascade deletes to delete the related comic book artist records.

This works fine for comic books, but for artists or series, we may not want

users to be able to delete a large number of related comic book records.

Let's look at a couple of alternative strategies for handling deletes.

One option would be to retrieve and display related data

on the detail page for a record that the user is trying to delete.

For instance, under Artist Detail page,

we would display all of the comic books that the artist is associated with.

We could then disable the Delete button, and

display a tool tip that lets the user know that the artist must first be removed from

all of the listed comic books before the artist can be deleted.

This is much more of a conservative approach than just

letting the cascade deletes happen.

But while it prevents the deletion of records that are in use,

it does give the user the information that they need in order to move forward.

If they, in fact, need to actually delete the record in question, another option

would be to allow the user to delete the records, even if they are in use.

But instead of physically deleting the record from the database,

we simply mark the record as deleted.

This is typically done by setting an active property to the value of false.

These kinds of deletes are known as Logical Deletes.

Allowing users to perform Logical Deletes

give developers a way to grant users more power in the application

while still retaining some level of control over the data.

For example, a user might delete a record,

only to realize later that they shouldn't have done that.

To undo the deletion, they could contact an administrator or

superuser do it in turn.

Use a special page to search for and undeleted the deleted record.

By saving this active property back to a value of true.

Logical Deletes seem too good to be true, right?

Well, there are some draw backs to be aware of.

If your web app requires users to delete large numbers of records,

your database can grow unexpectantly large,

as deleted records are never actually removed from the database.

Another draw back is that most of your queries will need to filter

out records who's active values are false.

Otherwise, list pages in the web app might unintentionally contain deleted records.

None of these issues are insurmountable.

There are simply things you need to consider when you're deciding

how you handle deletes in your web app.

Furthermore, you can even mix and match approaches within the same app.

Critical record types could use logical deletes,

while other record types could use physical deletes.

Coming up next, we'll review the Comic Book Artist Controller, and

give you a chance to finish implementing it on your own.