Как игнорировать исключение DbUpdateConcurrencyException при удалении объекта

Как насчет?

Db.Entry(itemToRemove).State = EntityState.Deleted;

bool saveFailed;
do
{
    saveFailed = false;
    try
    {
       Db.SaveChanges();
    }
    catch(DbUpdateConcurrencyException ex)
    {
       saveFailed = true;
       var entry = ex.Entries.Single();
       //The MSDN examples use Single so I think there will be only one
       //but if you prefer - do it for all entries
       //foreach(var entry in ex.Entries)
       //{
       if(entry.State == EntityState.Deleted)
          //When EF deletes an item its state is set to Detached
          //http://msdn.microsoft.com/en-us/data/jj592676.aspx
          entry.State = EntityState.Detached;
       else
          entry.OriginalValues.SetValues(entry.GetDatabaseValues());
          //throw; //You may prefer not to resolve when updating
       //}
    }
} while (saveFailed);

Подробнее здесь: Разрешение оптимистичных исключений параллелизма

Вы можете обработать DbUpdateConcurrencyException, а затем вызвать Refresh(RefreshMode,IEnumerable) с RefreshMode.StoreWins и вашими удаленными объектами в качестве параметра.

try{
  Db.Entry(itemToRemove).State = EntityState.Deleted;
  Db.SaveChanges();
}
catch(DbUpdateConcurrencyException)
{
  IObjectContextAdapter adapter = Db;

  adapter.ObjectContext.Refresh(RefreshMode.StoreWins, context.ObjectStateManager.GetObjectStateEntries(System.Data.EntityState.Deleted));
  Db.SaveChanges();
}

На основе кода из https://msdn.microsoft.com/en-US/data/jj592904, но где я добавил бесконечный счетчик циклов (на всякий случай, вы никогда не знаете, верно?) и перебирает все записи в списке исключений.

var maxTriesCounter = 20;
bool saveFailed;
do
{
    saveFailed = false;
    maxTriesCounter--;
    try
    {
        context.SaveChanges();
    }
    catch (DbUpdateConcurrencyException ex)
    {
        saveFailed = true;
        foreach (var entry in ex.Entries)
        {
            entry.Reload();
        }
    }
} while (saveFailed && maxTriesCounter > 0);

Вот что я использую. Отсоедините все записи о проблемах после сохранения.

Db.Entry(itemToRemove).State = EntityState.Deleted;

while(true)
    try {
        Db.SaveChanges();
        break;
    } catch (DbUpdateConcurrencyException ex) {
        ex.Entries.ToList().ForEach(x=>x.State=EntityState.Detached);
    }

Или вы можете добавить пользовательскую функцию SaveChanges в свой класс DbContext и использовать ее всякий раз, когда вам нужно игнорировать эти ошибки.

    public int SaveChanges_IgnoreConcurrencyExceptions  () {
        while(true)
            try {
                return this.SaveChanges();
            } catch (DbUpdateConcurrencyException ex) {
                ex.Entries.ToList().ForEach(x => x.State=EntityState.Detached);
            }
    }

Это мой подход:

    public async Task DeleteItem(int id)
    {
        bool isDone = false;
        while (!isDone)
        {
            var item= await dbContext.Items.AsNoTracking().SingleOrDefaultAsync(x=> x.id== id);
            if (item== null)
                return;

            dbContext.Items.Delete(item);
            try
            {
                await dbContext.CommitAsync();
                return;
            }
            catch (DbUpdateConcurrencyException ex)
            {
            }
        }

    }

Это другой подход:

        context.Delete(item);
        bool saveFailed;
        do
        {
            saveFailed = false;

            try
            {
                await context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException ex)
            {
                saveFailed = true;
                var entity = ex.Entries.Single();
                await entity.Single().ReloadAsync();

                if (entity.State == EntityState.Unchanged)// entity is already updated
                    context.Delete(item);;
                else if (entity.State == EntityState.Detached) // entity is already deleted
                    saveFailed =false;
            }
        } while (saveFailed);

ReloadAsync() метод от Документы Майкрософт :

Перезагружает объект из базы данных, перезаписывая любые значения свойств значениями из базы данных.

Сущность будет находиться в состоянии Unchanged после вызова этого метода, если сущность не существует в базе данных, и в этом случае сущность будет отключена. Наконец, вызов Reload для добавленного объекта, который не существует в базе данных, не является операцией. Обратите внимание, однако, что добавленный объект может еще не иметь своего постоянного значения ключа.

Я опубликовал этот вопрос давным-давно, но недавно ему было уделено некоторое внимание, поэтому я хотел бы добавить решение, которое я действительно использую.

//retry up to 5 times
for (var retries = 0; retries < 5; retries++)
{
    try
    {
        Db.SaveChanges();
        break;
    }
    catch (DbUpdateConcurrencyException ex)
    {
        foreach (var entity in ex.Entries)
        {
            entity.State = EntityState.Detached;
        }
    }
}

Вещи, которые я рассмотрел - я НЕ хотел использовать ReloadAsync() или ObjectContext.Refresh, поскольку я хотел игнорировать элементы, удаленные в другом процессе, БЕЗ каких-либо дополнительных накладных расходов на базу данных. Я добавил в цикл for как простую защиту от бесконечных циклов - не то, что должно произойти, но я человек с ремнем и фигурными скобками, а не поклонник while(true), если этого можно избежать. Нет необходимости в локальной переменной, такой как isDone или saveFailed - просто сломайте, если мы успешно сохранили. Не нужно приводить ex.Entries к списку, чтобы перечислить его — то, что вы можете написать что-то в одной строке, не делает его лучше.