Let's look at updating entities, specifically updating

comic book entities in the repository classes UpdateComicBook method.

As mentioned in the previous video,

EF tracks the changes to entities that are loaded into the context.

The UpdateComicBook method is past an instance of a comic book entity, but

that entity is not being tracked by the context.

Entities that are not being tracked by the context are said to be disconnected or

detached.

There are a number of ways that we can persist data changes contained within

disconnected or detached entities.

Our first option is to retrieve the entity from the database.

Then write code to manually update the property values.

To retrieve the entity, we can use the DB set find method.

Don't forget, we need to start with getting an instance of the context.

Using (Context context

= GetContext()).

Then we can retrieve the comic book,

ComicBook comicBookToUpdate=

Context.ComicBooks.Find(comicBook.Id).

Then we simply update the retrieved entity property values with the values from

the passed in entity.

comicBookToUpdate.SeriesId = comicBook.seriesId.

comicBookToUpdate.IssueNumber =

comicBook.IssueNumber.

comicBookToUpdate.Descriptions =

comicBook.Description.

comicBookToUpdate.PublishedOn =

comicBook.PublishedOn.

And then comicBookToUpdate.AverageRating

= comicBook.AverageRating, and call the SaveChanges method.

When we call the SaveChanges method,

EF will detect the changes to the entity that is being tracked in the context.

Generate a sequel update statement and

execute that statement against the database.

All this approach is simple and

easy to understand, it's tedious to write and maintain.

Let's look at another option.

In this option,

we still use the DB set find method to retrieve the entity from the database.

But instead of manually setting the new property values,

we retrieve the entity's entry from the context.

And call the current value's set values method to copy the passed in entity's

property values to the entry's current values collection.

context.Entry(ComicBookToUpdate).CurrentV-

alues.SetValues, then pass

in the (comicBook) parameter.

After calling the sub values method, the entity state assuming that at least

one property value is updated, will be set to modified.

A state of modified indicates that the entity has a change

that hasn't been persisted to the database.

When we call the SaveChanges method, EF will generate a SQL update statement for

the modified entity and execute that statement against the database.

Let's test our changes.

Set a break point just after the call to the save changes method and run the app.

Enter 3 to view the detail for issue number 3 of the bone series.

Then enter U to update the comic book.

Let's change the average rating.

Enter 5 to select a property, then enter 7 for the value.

Enter S to save the comic book.

Now, we're at our break point.

The save changes method was just called.

In the output window, we can see the queries that were generated and executed.

The first query was the query to retrieve the comic book entity.

And the second query was to update the average rating column.

This option is an improvement over the first.

And that we don't have to manually update the entity properties.

A downside to both approaches is that we have to retrieve the entity

from the database.

Which means that updating an entity requires two queries.

One to retrieve the entity and

another to persist any changes to the entity to the database.

Let's look at an option that doesn't require two queries.

Instead of retrieving the entity from the database,

we can attach the passed-in entity to the context using the DB set attach method.

context.ComicBooks.Attach(comicBook).

After attaching the entity to the context, its state will be set to unchanged.

EF is unable to detect whether or not any of the entity's property values

are different from the values that are currently in the database.

We can force EF to treat the entity's values as new

values by setting the associated entry state to modified.

context.Entry(comicBook).State = EntityState.Modified.

Now, when we call the SaveChanges method,

EF will persist each of the entity's property values to the database.

Let's test our changes again.

Enter 3 to view the detail for issue number 3 of the bone series.

Then enter U to update the comic book.

Let's change the description.

Enter 3 to select the property.

This is my new description.

Then enter S to save the comic book.

We're at our break point again, just after the SaveChanges method call.

In the output window, we can see the query that was generated and executed.

So we were able to eliminate the query to retrieve the entity from the database.

But on the downside, as we can see in the generated query,

every column value is being updated in the database.

Not just the ones that have actually changed.

In most situations, this approach works fine.

Though, there might be times that an entity contains a property that shouldn't

ever be updated.

Let's imagine that once a comic book has been added to the database,

its issue number shouldn't be changed.

Let's start with rewriting this line of code, so

that we retrieve the current books entry into a variable.

Var comicBookEntry = context.Entry(comicBook).

Then, comicBookEntry.State

= EntityState.Modified.

Then use the entries property method

to get a reference to the issued number properties entry object.

And set the entries is modified property to false.

comicBookEntry.Property("IssueNumber").Is-

Modified = false;.

This line of code will prevent the IssueNumber property from being included

in the generated SQL update query.

Go ahead and remove or comment out this line of code.

We want our users to be able to change a comicBook's issue number.

After a code challenge, we'll see how to delete entities