Explain how to handle concurrency in EF Core.

Handling concurrency in Entity Framework Core (EF Core) is essential to prevent data conflicts and ensure data integrity, especially in scenarios where multiple users or processes are updating the same data. EF Core provides several mechanisms to handle concurrency, allowing applications to resolve conflicts gracefully or apply custom resolution strategies. Here’s an overview of concurrency control techniques in EF Core and how to implement them.

Types of Concurrency in EF Core

1. Optimistic Concurrency: Assumes conflicts are rare and allows multiple users to access the same data for updates. When a conflict occurs, the application detects it and decides how to resolve it.
2. Pessimistic Concurrency: Locks resources to prevent concurrent modifications but is not natively supported by EF Core and typically requires database-specific features.

Implementing Optimistic Concurrency in EF Core

Optimistic concurrency in EF Core can be implemented using a Concurrency Token. A concurrency token is a column in the database that EF Core checks before saving changes, ensuring the data hasn’t been modified by another process.

Step 1: Define a Concurrency Token in the Model

Use attributes or Fluent API configurations to designate a property as a concurrency token. The RowVersion property is commonly used, but any property can serve as a concurrency token.

Example Using RowVersion with Attributes:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }

    [Timestamp]
    public byte[] RowVersion { get; set; }
}

In this example:

• The RowVersion property is marked with the [Timestamp] attribute, which configures EF Core to use it as a concurrency token.
• EF Core updates RowVersion with a new timestamp or version value on each update, allowing detection of concurrent updates.

Example Using Fluent API:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>()
                .Property(p => p.RowVersion)
                .IsRowVersion();
}

Step 2: Handle Concurrency Exceptions

When EF Core detects a concurrency conflict, it throws a DbUpdateConcurrencyException. This exception contains information about the conflicting entries, allowing the application to decide on a resolution strategy.

Handling Concurrency in Code:

public async Task UpdateProduct(Product updatedProduct)
{
    try
    {
        _context.Products.Update(updatedProduct);
        await _context.SaveChangesAsync();
    }
    catch (DbUpdateConcurrencyException ex)
    {
        // Resolve concurrency conflict
        foreach (var entry in ex.Entries)
        {
            if (entry.Entity is Product)
            {
                // Get the current values from the database
                var databaseValues = entry.GetDatabaseValues();

                if (databaseValues != null)
                {
                    // Set current database values to entity's original values
                    entry.OriginalValues.SetValues(databaseValues);
                    
                    // Optional: Custom resolution strategy
                    // entry.CurrentValues["Price"] = Math.Max(
                    //    (decimal)entry.CurrentValues["Price"],
                    //    (decimal)databaseValues["Price"]);

                    // Reattempt the update
                    await _context.SaveChangesAsync();
                }
                else
                {
                    // Entity no longer exists in the database, handle accordingly
                }
            }
        }
    }
}

In this example:

• The DbUpdateConcurrencyException is caught during SaveChangesAsync.
• GetDatabaseValues() retrieves the current values in the database, allowing comparison and resolution.
• The original values are updated to reflect the current database values, which can then be retried or merged with custom logic.

Conflict Resolution Strategies

1. Client Wins: The client’s values override the database values, discarding changes made by others. Set the OriginalValues to the CurrentValues and save changes again.
2. Store Wins: The current database values override the client’s values, keeping the database as the single source of truth.
3. Custom Resolution: A custom strategy where you can manually merge client and database values, for example by calculating the highest price if two users update a product's price.

Other Concurrency Techniques

1. Concurrency with Multiple Tokens

• EF Core allows multiple properties to serve as concurrency tokens. For example, you could use both a timestamp column and an integer-based version column for more granular control.

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    [Timestamp]
    public byte[] RowVersion { get; set; }
    public int Version { get; set; }
}

2. Database-Level Concurrency Handling

• For scenarios where pessimistic concurrency is required, implement locking directly in the database (e.g., SQL Server’s WITH (ROWLOCK, UPDLOCK) hints). However, this approach can lead to contention and blocking, which affects performance and scalability.

Common Interview Questions on EF Core Concurrency

1. How does EF Core handle concurrency by default?

   • EF Core does not enable concurrency control by default; developers must define a concurrency token, such as a RowVersion, to detect conflicts.

2. What is a concurrency token, and why is it used?

   • A concurrency token is a property used by EF Core to detect conflicting updates in the database, ensuring data integrity by tracking version changes.

3. Explain the difference between optimistic and pessimistic concurrency.

   • Optimistic concurrency assumes conflicts are rare and allows concurrent access, checking for conflicts only at save time. Pessimistic concurrency locks data during access to prevent conflicts but is more resource-intensive.

4. How would you resolve a DbUpdateConcurrencyException?

   • By catching the exception and using GetDatabaseValues to compare current and database values, allowing for a custom conflict resolution strategy such as “Client Wins” or “Store Wins.”

5. Can you use multiple properties as concurrency tokens in EF Core?

   • Yes, multiple properties can serve as concurrency tokens, allowing finer control over conflict detection across multiple columns.

Using these concurrency control strategies in EF Core helps maintain data consistency in multi-user environments, ensuring the application handles conflicts effectively without sacrificing performance.