Revision history [back]

The System.Data.Entity.Infrastructure.CommitFailedException typically occurs when multiple threads try to access the same entity object in a database simultaneously, resulting in concurrency conflicts. To address this issue, you can use one of the following approaches:

1. Use a Mutex: A Mutex (short for mutual exclusion) is a synchronization object that allows you to restrict access to a shared resource to only one thread at a time. You can use a Mutex to synchronize access to your entity objects and prevent multiple threads from accessing them at the same time.

2. Use optimistic concurrency: In optimistic concurrency, each record in the database table has a version number associated with it. Whenever a thread updates a record, it checks the version number to ensure that it matches the version of the record in the database. If the versions match, the thread updates the record and increments its version number. If the versions do not match, the thread knows that another thread has already modified the record, and it can take appropriate action (such as aborting the transaction or retrying the operation).

3. Use pessimistic concurrency: In pessimistic concurrency, you lock the record in the database before updating it. This prevents any other thread from accessing the record until the lock is released. While this approach is effective in preventing concurrency conflicts, it can also result in poor performance and scalability.

To implement these approaches, you can modify your code to use the appropriate synchronization techniques and concurrency models. You may also need to modify your database schema to include version fields or locking mechanisms. Consult the documentation for your database management system and Entity Framework for more information on concurrency control.