Resolve DbUpdateConcurrencyException with Client Wins, Store Wins, or Field-Level Merge

Learning outcomes

A concurrency exception is not a request to “retry until it works.” It is a request to decide what the application means when the proposal, the original version, and the current database version disagree. ServiceHub needs different policies for different fields and workflows.

1. The three value sets form a merge problem

A field-level merge is analogous to a three-way source-control merge: original is the common base, proposed is one branch, database is the other. If only one side changed a property, merging can be safe. If both sides changed it differently, the domain must decide.

2. Store wins: discard the stale proposal

catch (DbUpdateConcurrencyException ex){    foreach (var entry in ex.Entries)    {        await entry.ReloadAsync(ct);        // Entry is now aligned to the current store row and typically Unchanged.    }    return Conflict("The work order changed; current server state was reloaded.");}

Store-wins is appropriate when the attempted edit is low value, automatically recomputable, or the user should review the latest state before editing again. It is not “successful save”; the client proposal was discarded and that outcome must be visible.

3. Client wins: refresh the precondition, then retry deliberately

for (var attempt = 1; attempt <= 2; attempt++){    try    {        await db.SaveChangesAsync(ct);        break;    }    catch (DbUpdateConcurrencyException ex) when (attempt < 2)    {        foreach (var entry in ex.Entries)        {            var databaseValues = await entry.GetDatabaseValuesAsync(ct);            if (databaseValues is null)                throw new WorkOrderDeletedConflictException();            // Keep proposed values; accept the database version as the new comparison base.            entry.OriginalValues.SetValues(databaseValues);            // Publish a fresh application-managed version for the retry.            entry.CurrentValues[nameof(WorkOrder.Revision)] = Guid.NewGuid();        }    }}

This intentionally overwrites conflicting database fields with the client's current proposal if the second attempt succeeds. Use it only when the business policy explicitly says the client has authority. Refreshing originals is what changes the next predicate; simply retrying the exact stale predicate achieves nothing.

4. Field-level merge: compare each property to the common base

var proposed = entry.CurrentValues;var original = entry.OriginalValues;var database = await entry.GetDatabaseValuesAsync(ct)    ?? throw new WorkOrderDeletedConflictException();var mergeableProperties = new[]{    nameof(WorkOrder.Summary)    // Add only domain fields whose merge policy is explicitly defined.};foreach (var propertyName in mergeableProperties){    var was = original[propertyName];    var mine = proposed[propertyName];    var theirs = database[propertyName];    var mineChanged = !Equals(mine, was);    var theirsChanged = !Equals(theirs, was);    if (!mineChanged && theirsChanged)        proposed[propertyName] = theirs;       // take store-only edit    else if (mineChanged && theirsChanged && !Equals(mine, theirs))        throw new WorkOrderMergeConflictException(propertyName, mine, theirs);}// Generated/audit/FK fields are not implicitly merged by this allow-list.entry.OriginalValues.SetValues(database);entry.CurrentValues[nameof(WorkOrder.Revision)] = Guid.NewGuid();await db.SaveChangesAsync(ct);

This generic shape is useful for teaching, but production merge policy should usually be explicit per domain field. A summary decision, technician assignment, approval status, and financial amount do not have the same merge semantics.

5. The backing field does not change the concurrency method

ServiceHub maps Summary through the _summary backing field. Conflict resolution should still use the mapped EF property metadata named Summary, as Chapter 11 established. Do not attempt entry.Property("_summary") unless the field itself was separately configured as a field-only property.

var proposedSummary = entry.CurrentValues[nameof(WorkOrder.Summary)];var originalSummary = entry.OriginalValues[nameof(WorkOrder.Summary)];var databaseSummary = databaseValues[nameof(WorkOrder.Summary)];

6. Deleted rows require a different decision

GetDatabaseValuesAsync can return null when the row no longer exists. “Client wins” is no longer merely an update decision: recreating a deleted aggregate may violate identifiers, uniqueness, workflow history, foreign keys, or legal retention rules.

7. Hands-on policy lab

1. Reset SQLite and prepare two contexts reading the same work order/revision.
2. Make writer A change Summary and commit.
3. Make writer B change the same Summary and capture DbUpdateConcurrencyException.
4. Run store-wins and verify B's proposed summary is discarded.
5. Reset; run bounded client-wins and verify the final database summary/revision.
6. Reset; create non-overlapping changes in a teaching pair of mapped fields and run the three-way merge.
7. Create a same-field divergent edit and verify your merge policy surfaces an irreconcilable conflict rather than picking arbitrarily.
8. Delete the row from writer A and verify B handles GetDatabaseValuesAsync == null.

8. Production judgment and bridge

Conflict resolution belongs close to domain/application policy, not in a generic “retry all concurrency exceptions” utility. Emit structured telemetry such as entity type, operation, attempt count, and conflict field names—without dumping confidential values. Lesson 4 moves that policy across process boundaries where versions become ETags, message preconditions, and offline-edit contracts.

Authoritative references

• Handling Concurrency Conflicts - EF Core — Current/Original/DatabaseValues and retry pattern.
• Accessing Tracked Entities - EF Core — PropertyValues APIs and entry metadata.
• DbUpdateConcurrencyException API — exception contract and conflicting Entries.
• GetDatabaseValuesAsync API — reading current store values for conflict resolution.
• EF Core diagnostics — observing conflicts without relying on exception text parsing.