Shulou(Shulou.com)06/01 Report--

Topic (EntityFramework Core concurrency)

I believe you are no stranger to the topic of concurrency. When the amount of data is relatively large, we need to consider concurrency, and there are many concurrency involved. In EF Core, we divide concurrency into several sections to state, so that everyone does not look too tired and easy to accept. We go from shallow to deep. First, let's take a look at the given Blog entity class.

Public class Blog: IEntityBase {public int Id {get; set;} public string Name {get; set;} public string Url {get; set;} public ICollection Posts {get; set;}}

We will not describe the dependency injection repository in VS2015. It is relatively simple. Let's take a look at the two methods in the controller, one is to render the data, and the other is to update the data, as follows:

Public class HomeController: Controller {private IBlogRepository _ blogRepository; public HomeController (IBlogRepository blogRepository) {_ blogRepository = blogRepository;} public IActionResult Index () {var blog = _ blogRepository.GetSingle (d = > d.Id = = 1); return View (blog) } [HttpPost] public IActionResult Index (Blog obj) {try {_ blogRepository.Update (obj); _ blogRepository.Commit ();} catch (Exception ex) {ModelState.AddModelError (", ex.Message) } return View (obj);}}

The view rendering data is as follows:

@ using StudyEFCore.Model.Entities@model Blog @ using (Html.BeginForm ("Index", "Home", FormMethod.Post)) {blog ID: @ Html.TextBoxFor (m = > m.Id New {@ readonly = "readonly"}) blog name: @ Html.TextBoxFor (m = > m.Name) blog address: @ Html.TextBoxFor (m = > m.Url) } @ Html.ValidationSummary ()

The final data rendered on the page is as follows:

Next, let's demonstrate how to cause concurrency problems, as follows:

Above, we break the point after updating the value of the view page and then before SaveChanges, then we change its value in the database, and then SaveChanges will report an exception at this time. The error message is as follows:

See http:

Because there is no SaveChanges after changing its value on our page, but at this time we modify the value of Name, then we come to SaveChanges, and the above error is reported, which is the concurrency problem we are talking about in this section. Now that this problem has arisen, how can we solve the concurrency problem in EF Core? We have two ways here, and we will state them one by one.

EF Core concurrency solution 1 (concurrent Token)

Since we are going to talk about concurrent Token, before that, we need to talk about how the concurrent Token works. When we identify the property as concurrent Token, when we load its value from the database, the concurrent Token of the corresponding attribute is allocated through the context. When the same value of the assigned concurrent Token attribute is updated or deleted, the concurrent Token of the attribute will be forced to detect. It detects the number of rows affected, and if the concurrency has been matched, then one row will be updated, and if the value has been updated in the database, no data rows will be updated. For updates or deletes by including concurrent Token on the WHERE condition. Next, we set the Name to be updated as concurrent Token, as follows:

Public class BlogMap: EntityMappingConfiguration {public override void Map (EntityTypeBuilder b) {b.ToTable ("Blog"); b.HasKey (k = > k.Id); b.Property (p = > p.Name). IsConcurrencyToken (); b.Property (p = > p.Url) B.HasMany (p = > p.Posts) .WithOne (p = > p.Blog) .HasForeignKey (p = > p.BlogId);}}

When we migrate and update the model after making the above settings, we will eventually throw the following exception:

Database operation expected to affect row (s) but actually affected row (s). Data may have been modified or deleted since entities were loaded. See http:

Next, let's take a look at how rows are versioned to resolve concurrency.

EF Core concurrency solution II (line version)

A new timestamp is generated when we insert or update, and this property is also treated as a concurrent Token, which ensures that an exception is thrown when we update the value but its value has been modified. So how to use the row version? (we'll only talk about Fluent API about Data Annotations. Please find your own data.) define the following attributes in the entity:

Public byte [] RowVersion {get; set;}

Then configure the property as follows.

B.Property (p = > p.RowVersion). IsConcurrencyToken (). ValueGeneratedOnAddOrUpdate ()

When we do this demonstration again, we are sure to throw the same exception message.

Neither of the above can solve the concurrency problem in EF Core in essence, so what should we do to solve the concurrency problem? please move on.

Resolving EF Core concurrency conflicts

We resolve concurrency conflicts in EF Core with three settings, as follows:

Current value (Current values): attempts to write the currently modified value to the database.

Original value (Original values): the value that needs to be retrieved from the database without any modification.

Data value (Database values): the value currently saved in the database.

Because concurrency will throw an exception, we need to resolve it in the exception caused by concurrency conflict in SaveChanges. Concurrency exceptions appear in the DbUpdateConcurrencyException class, and we only need to solve them here. For example, we need to modify the value of Name above, we have laid the groundwork and set up concurrent Token. However, it will still throw concurrent exceptions and fail to solve the problem. This is only the premise of solving concurrent exceptions. Because we use the warehouse to manipulate data, but concurrent exceptions will take advantage of the EF context, we define additional interfaces to operate directly through the context. We define an interface as follows.

Public interface IBlogRepository: IEntityBaseRepository {void UpdateBlog (Blog blog);}

Resolving concurrency exceptions is handled through the EF context.

Public class BlogRepository: EntityBaseRepository, IBlogRepository {private EFCoreContext _ efCoreContext; public BlogRepository (EFCoreContext efCoreContext): base (efCoreContext) {_ efCoreContext = efCoreContext;} public void UpdateBlog (Blog blog) {try {_ efCoreContext.Set () .Update (blog); _ efCoreContext.SaveChanges () } catch (DbUpdateConcurrencyException ex) {foreach (var entry in ex.Entries) {if (entry.Entity is Blog) {var databaseEntity = _ efCoreContext.Set () .AsNoTracking () .Single (p = > p.Id = = ((Blog) entry.Entity) .ID) Var databaseEntry = _ efCoreContext.Entry (databaseEntity); foreach (var property in entry.Metadata.GetProperties ()) {var proposedValue = entry.Property (property.Name) .CurrentValue; var originalValue = entry.Property (property.Name). OriginalValue Var databaseValue = databaseEntry.Property (property.Name) .CurrentValue; / / TODO: Logic to decide which value should be written to database var propertyName = property.Name If (propertyName = = "Name") {/ / Update original values to entry.Property (property.Name). OriginalValue = databaseEntry.Property (property.Name) .CurrentValue; break } else {throw new NotSupportedException ("Don't know how to handle concurrency conflicts for" + entry.Metadata.Name) } / / Retry the save operation _ efCoreContext.SaveChanges ();}

The above is the general solution to concurrency exceptions, we just pay attention to the TODO logic shown above, we need to get the concurrent attributes, and then update its value, we will have concurrency for Name, so when traversing entity attributes, we can get Name, and then update its value, simple and rude, complete victory. Let's see the following demonstration.

Above, we modify Name to efcoreefcore, modify the Name in the database before SaveChanges, and then SaveChanges, there will certainly be concurrency exceptions. We will deal with them in concurrency exceptions. Finally, we can clearly see that the Name in the final database is updated to efcoreefcore. We can guarantee that concurrency can be solved in the last retry to a certain extent.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.