This workshop will be retired on May 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
Preview
Start a free Courses trial
to watch this video
Let's see how to update our approach for deleting comic books to handle concurrency.
Using a Stub to Delete Entities in a Generic Base Repository Class
In order to keep our approach as simple as possible, we implemented the Delete method that utilizes a stub entity approach in the ComicBooksRepository class instead of the BaseRepository generic base class. To implement this method in the generic base class, we need to add a couple of generic constraints.
public abstract class BaseRepository<TEntity>
where TEntity : class, IVersionedEntity, new()
{
...
}
Notice that we added IVersionedEntity and new() as generic constraints. The IVersionedEntity constraint enforces that the generic type implement the IVersionedEntity interface and the new() constraint enforces that the generic type define a default constructor.
By enforcing that the generic type implement the IVersionedEntity interface and have a default constructor, we can instantiate an instance of the generic type and set any of the properties defined on the IVersionedEntity interface like this:
public void Delete(int id, byte[] rowVersion)
{
var entity = new TEntity()
{
Id = id,
RowVersion = rowVersion
};
Context.Entry(entity).State = EntityState.Deleted;
Context.SaveChanges();
}
For reference, here's the IVersionedEntity interface:
public interface IVersionedEntity
{
int Id { get; set; }
byte[] RowVersion { get; set; }
}
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
Our current approach for deleting comic
books doesn't handle concurrency.
0:00
Let's look at an example.
0:04
I already added Bone # 4,
so that we could use it for
0:06
testing our delete implementation.
0:09
I'll open the detail page
into another tab, and
0:14
then click the delete button to
view the delete comic book page.
0:18
Back in the first tab,
I'll update the comic book.
0:23
Then in the second tab,
I'll click the delete button.
0:30
And the comic book is deleted
0:36
without any warning that the entity
was updated by another user.
0:38
Even worse, if another user had deleted
the same comic book before we could,
0:43
we would have gotten
an unhandled exception.
0:48
We can improve this experience by
updating the delete comic book page
0:50
to take advantage of our
concurrency control.
0:54
We'll start our refactoring
of the delete comic book page
0:57
by updating the comic books
controller delete action methods, and
0:59
their associated view,
to use a view model.
1:03
As with our other pages that utilize
view models, this will give us
1:06
a convenient way to pass multiple values
from our action methods to the view.
1:10
Let's add the view model class
to the view models folder.
1:15
I'll name the class,
ComicBooksDeleteViewModel.
1:20
Most of what we need for
1:28
this view model already exists in
the ComicBook's edit view model class.
1:29
The Id property that enables model
binding to be able to bind the Id route
1:38
parameter value to the ComicBook Id
model property, and
1:42
the comic book has been deleted property.
1:46
And in the ComicBooksBaseViewModel
base class, the comic book property.
1:53
We could inherit from
the ComicBooksBaseViewModel, but
2:00
we only need the comic book property for
our new view model.
2:03
We could so some refactoring and
2:07
create a new shared base class,
possibly even a generic base class.
2:08
But that just feels like it over
complicates things too much,
2:13
at least at this point in time.
2:17
Given that, let's just create
a stand alone class, by copying and
2:18
pasting what we need into this class.
2:22
Now that we have our view model, let's
update the comics book controller delete
2:34
get and
post action methods to make use of it.
2:39
For the get action method, we just need to
instantiate an instance set the ComicBook
2:43
property value, and
pass it into the view method call.
2:48
For the post action method we need
to replace the integer ID parameter
2:57
with the ComicBooksDeleteViewModel
viewModel parameter.
3:01
And in the call to
the repositories delete method,
3:07
replace the reference to the ID
parameter with view model ComicBook.Id.
3:09
Then let's wrap the existing method
implementation and then try catch block.
3:14
And update the cache clause exception
type to DbUpdateConcurrencyException,
3:23
and add an argument in order to capture
a reference to the thrown exception.
3:28
Our cache block implementation will
be very similar to what we did
3:35
in the edit post action method.
3:39
So let's grab a copy that code
3:41
Actually, the only thing that we need to
modify are the error messages that we're
3:48
returning to the user, well and fix
this reference to the ComicBook entity.
3:53
In the first error message,
we can change updated to deleted.
3:58
The second message will require
a more substantial change.
4:04
Let's change the message to,
the ComicBook being
4:09
Deleted has already been
updated by another user.
4:15
If you still want to not make changes, but
if you still want to delete the ComicBook
4:19
Then click the Save,
change that to Delete button again.
4:32
Otherwise, click the Cancel button
to not discard your changes.
4:37
To return to the detail page.
4:42
After we add the model error, we need
to return a call to the view method.
4:51
Passing in the viewModel instance.
4:55
Before we move on to updating the view,
let's take a look at the repository method
4:58
that we're calling in order
to delete the comic book.
5:02
The base repositories delete method
retrieves the entity from the database in
5:08
order to remove it from the identity set.
5:12
Under normal circumstances,
this would work as expected.
5:16
But we need an implementation that will
work with our data concurrency control.
5:19
The problem is when we retrieve
the entity from the database.
5:23
We're getting the entities
current row version value.
5:27
That prevents EF from detecting any
updates, or deletes that might have been
5:30
performed since the user initially
loaded the delete comic book page.
5:34
In a moment, we'll see how to ensure that
the entities tracking property value
5:39
from the initial page
load doesn't get lost.
5:43
While we're here though, let's add a new
delete method to the ComicBookRepository.
5:47
That will work correctly with
our data concurrency control.
5:51
When need to delete method that
utilizes a stub entity approach, so
5:54
that we can explicitly set the tracking
property value that should be used
5:58
when EF generates the delete
sequel statement.
6:02
For now, I'm going to add this
method to the ComicBooksRepository.
6:05
Though it's certainly possible
to push this method down
6:09
into the generic base class.
6:12
If you'd like to learn more about how
to do that, see the teachers notes for
6:14
more information.
6:17
We want the call word of our delete method
to pass in the entities tracking property
6:18
value in addition to the entities Id.
6:22
For the tracking property value,
let's name the parameter row Version, so
6:26
that it aligns with the entity's
row version property name.
6:30
Then let's create our stub comic
book entity, setting the Id and
6:35
row version properties,
to their respective parameter values.
6:38
And let's finish up by calling the
Context's Entry method, setting the entry
6:45
state property to deleted, and
calling the Context save changes method.
6:49
Now that we have our new data concurrency
control friendly delete repository method,
6:55
let's call it from the delete
post action method.
7:01
That's easy to do.
7:03
We just need to pass on the view model,
7:05
ComicBook.rowVersion property
value as the second argument.
7:07
Let's move on to our final part of this
refactoring effort, updating the view.
7:11
Now that we're passing
an instance of our view model,
7:18
from the controller to the view, instead
of an instance of the kind book entity,
7:20
we need to update the at model directive.
7:24
Before moving on,
let's also fix this bad reference.
7:35
When the data concurrency
exception is thrown,
7:42
we're adding models error to the model
state in the action method, but
7:45
the user won't see those message unless
we rendered a validation summary section.
7:48
Let's add a call to
the validation summary,
7:53
HTML helper method right
inside the start of our form.
7:56
Actually, instead of
creating one from scratch,
8:00
let's grab a copy of
one from the edit view.
8:03
Also, when there's a data
concurrency error to display,
8:10
you want to avoid retrieving
the entity from the database again.
8:13
Remember, we want the ComicBook's.row
Version property as it was from
8:17
the initial page load to remain
consistent throughout the delete process.
8:21
Besides, if the entity was
deleted by another user,
8:26
it wouldn't even be possible to retrieve
the entity again from the database.
8:29
To persist the entity's row version
property value we can use a hidden field,
8:33
just like we did on
the edit comic book page.
8:36
Unlike the edit ComicBook page,
we don't have any text fields for
8:43
any of the other comic
book entity properties.
8:47
Given that,
in order to persist the series title and
8:50
issue number, we'll need to add hidden
fields for those properties as well.
8:52
And lastly, let's update the Cancel
button's href attribute URL generation.
8:57
That completes our refactoring.
9:11
Now we're ready to test our changes.
9:13
And we got a bad request error, but
9:17
that's because we tried to browse
directly to the delete view.
9:20
Let's navigate to the root of our website.
9:27
I'll start by adding Bone # 4, again.
9:32
Then I'll open the detail
page into another tab
9:48
And click the delete button to
view the delete ComicBook page.
9:56
Back in the first tab,
I'll update the ComicBook.
10:02
Then in the second tab,
I'll click the delete button.
10:08
And, we get an error message, letting us
know that the Comic Book has been updated.
10:15
Back in the first tab,
let's delete the Comic Book.
10:23
Then in the second tab,
I'll click the Delete button again.
10:31
And, we get an error message but
10:38
in this now that the Comic Book
has already been deleted.
10:39
Clicking the Cancel button,
takes us back to the list page.
10:44
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up