Як видалити декілька рядків у Entity Framework (без передбачень)

Я видаляю кілька елементів із таблиці за допомогою Entity Framework. Не існує стороннього ключа / батьківського об'єкта, тому я не можу впоратися з цим за допомогою OnDeleteCascade.

Зараз я роблю це:

var widgets = context.Widgets
    .Where(w => w.WidgetId == widgetId);

foreach (Widget widget in widgets)
{
    context.Widgets.DeleteObject(widget);
}
context.SaveChanges();

Це працює, але foreach клопоче мене. Я використовую EF4, але не хочу виконувати SQL. Я просто хочу переконатися, що я нічого не пропускаю - це так добре, як виходить, правда? Я можу абстрагувати його методом розширення або помічником, але десь ми все ще будемо робити передбачення, правда?

Якщо ви не хочете виконувати SQL безпосередньо, викликаючи DeleteObject у циклі - це найкраще, що ви можете зробити сьогодні.

Однак ви можете виконати SQL і все-таки зробити його повністю загальним призначенням за допомогою методу розширення, використовуючи описаний тут підхід .

Хоча ця відповідь була за 3.5. Для 4.0 я б, ймовірно, використовував новий API ExecuteStoreCommand під кришкою, а не опускався до StoreConnection.

EntityFramework 6 зробив це трохи легше .RemoveRange().

Приклад:

db.People.RemoveRange(db.People.Where(x => x.State == "CA"));
db.SaveChanges();

це так добре, як виходить, правда? Я можу абстрагувати його методом розширення або помічником, але десь ми все ще будемо робити передбачення, правда?

Ну так, хіба що ви можете перетворити його на двоколірне:

context.Widgets.Where(w => w.WidgetId == widgetId)
               .ToList().ForEach(context.Widgets.DeleteObject);
context.SaveChanges();

using (var context = new DatabaseEntities())
{
    context.ExecuteStoreCommand("DELETE FROM YOURTABLE WHERE CustomerID = {0}", customerId);
}

Я знаю, що це досить пізно, але якщо комусь потрібне просте рішення, класна річ, ви також можете додати до нього пункт де:

public static void DeleteWhere<T>(this DbContext db, Expression<Func<T, bool>> filter) where T : class
{
    string selectSql = db.Set<T>().Where(filter).ToString();
    string fromWhere = selectSql.Substring(selectSql.IndexOf("FROM"));
    string deleteSql = "DELETE [Extent1] " + fromWhere;
    db.Database.ExecuteSqlCommand(deleteSql);
}

Примітка: щойно тестовано з MSSQL2008.

Оновлення:

Наведене вище рішення не буде працювати, коли EF генерує оператор sql з параметрами , ось ось оновлення для EF5 :

public static void DeleteWhere<T>(this DbContext db, Expression<Func<T, bool>> filter) where T : class
{
    var query = db.Set<T>().Where(filter);

    string selectSql = query.ToString();
    string deleteSql = "DELETE [Extent1] " + selectSql.Substring(selectSql.IndexOf("FROM"));

    var internalQuery = query.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Where(field => field.Name == "_internalQuery").Select(field => field.GetValue(query)).First();
    var objectQuery = internalQuery.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Where(field => field.Name == "_objectQuery").Select(field => field.GetValue(internalQuery)).First() as ObjectQuery;
    var parameters = objectQuery.Parameters.Select(p => new SqlParameter(p.Name, p.Value)).ToArray();

    db.Database.ExecuteSqlCommand(deleteSql, parameters);
}

Це вимагає трохи роздумів, але добре працює.

Для всіх, хто використовує EF5, можна використовувати наступну бібліотеку розширень: https://github.com/loresoft/EntityFramework.Extended

context.Widgets.Delete(w => w.WidgetId == widgetId);

Все ще здається божевільним, що потрібно витягнути що-небудь назад із сервера просто для того, щоб видалити його, але принаймні повернення лише ідентифікаторів набагато швидше, ніж витягування повних сутностей:

var ids = from w in context.Widgets where w.WidgetId == widgetId select w.Id;
context.Widgets.RemoveRange(from id in ids.AsEnumerable() select new Widget { Id = id });

EF 6.1

public void DeleteWhere<TEntity>(Expression<Func<TEntity, bool>> predicate = null) 
where TEntity : class
{
    var dbSet = context.Set<TEntity>();
    if (predicate != null)
        dbSet.RemoveRange(dbSet.Where(predicate));
    else
        dbSet.RemoveRange(dbSet);

    context.SaveChanges();
} 

Використання:

// Delete where condition is met.
DeleteWhere<MyEntity>(d => d.Name == "Something");

Or:

// delete all from entity
DeleteWhere<MyEntity>();

Для EF 4.1,

var objectContext = (myEntities as IObjectContextAdapter).ObjectContext;
objectContext.ExecuteStoreCommand("delete from [myTable];");

Ви можете використовувати бібліотеки розширень для цього, як EntityFramework.Extended або Z.EntityFramework.Plus.EF6, є в наявності для EF 5, 6 або Core. Ці бібліотеки мають велику продуктивність, коли вам потрібно видалити або оновити, і вони використовують LINQ. Приклад видалення ( джерело плюс ):

ctx.Users.Where(x => x.LastLoginDate < DateTime.Now.AddYears(-2)) .Delete();

або ( джерело розширено )

context.Users.Where(u => u.FirstName == "firstname") .Delete();

Вони використовують нативні оператори SQL, тому продуктивність чудова.

Найшвидший спосіб видалення - це використання збереженої процедури. Я віддаю перевагу збереженим процедурам в проекті баз даних над динамічним SQL, оскільки перейменування будуть оброблені правильно та матимуть помилки компілятора. Динамічний SQL може посилатися на таблиці, які були видалені / перейменовані, викликаючи помилки часу виконання.

У цьому прикладі я маю дві таблиці List і ListItems. Мені потрібен швидкий спосіб видалити всі ListItems із заданого списку.

CREATE TABLE [act].[Lists]
(
    [Id] INT NOT NULL PRIMARY KEY IDENTITY, 
    [Name] NVARCHAR(50) NOT NULL
)
GO
CREATE UNIQUE INDEX [IU_Name] ON [act].[Lists] ([Name])
GO
CREATE TABLE [act].[ListItems]
(
    [Id] INT NOT NULL IDENTITY, 
    [ListId] INT NOT NULL, 
    [Item] NVARCHAR(100) NOT NULL, 
    CONSTRAINT PK_ListItems_Id PRIMARY KEY NONCLUSTERED (Id),
    CONSTRAINT [FK_ListItems_Lists] FOREIGN KEY ([ListId]) REFERENCES [act].[Lists]([Id]) ON DELETE CASCADE
)
go
CREATE UNIQUE CLUSTERED INDEX IX_ListItems_Item 
ON [act].[ListItems] ([ListId], [Item]); 
GO

CREATE PROCEDURE [act].[DeleteAllItemsInList]
    @listId int
AS
    DELETE FROM act.ListItems where ListId = @listId
RETURN 0

Тепер цікава частина видалення елементів та оновлення Entity Framework за допомогою розширення.

public static class ListExtension
{
    public static void DeleteAllListItems(this List list, ActDbContext db)
    {
        if (list.Id > 0)
        {
            var listIdParameter = new SqlParameter("ListId", list.Id);
            db.Database.ExecuteSqlCommand("[act].[DeleteAllItemsInList] @ListId", listIdParameter);
        }
        foreach (var listItem in list.ListItems.ToList())
        {
            db.Entry(listItem).State = EntityState.Detached;
        }
    }
}

Основний код тепер може використовувати його як

[TestMethod]
public void DeleteAllItemsInListAfterSavingToDatabase()
{
    using (var db = new ActDbContext())
    {
        var listName = "TestList";
        // Clean up
        var listInDb = db.Lists.Where(r => r.Name == listName).FirstOrDefault();
        if (listInDb != null)
        {
            db.Lists.Remove(listInDb);
            db.SaveChanges();
        }

        // Test
        var list = new List() { Name = listName };
        list.ListItems.Add(new ListItem() { Item = "Item 1" });
        list.ListItems.Add(new ListItem() { Item = "Item 2" });
        db.Lists.Add(list);
        db.SaveChanges();
        listInDb = db.Lists.Find(list.Id);
        Assert.AreEqual(2, list.ListItems.Count);
        list.DeleteAllListItems(db);
        db.SaveChanges();
        listInDb = db.Lists.Find(list.Id);
        Assert.AreEqual(0, list.ListItems.Count);
    }
}

Якщо ви хочете видалити всі рядки таблиці, ви можете виконати команду sql

using (var context = new DataDb())
{
     context.Database.ExecuteSqlCommand("TRUNCATE TABLE [TableName]");
}

TRUNCATE TABLE (Transact-SQL) Видаляє всі рядки з таблиці без реєстрації окремих видалень рядків. TRUNCATE TABLE аналогічний оператору DELETE, не має пункту WHERE; однак TRUNCATE TABLE швидше і використовує менше ресурсів системи та журналу транзакцій.

UUHHIVS's є дуже елегантним і швидким способом пакетного видалення, але його потрібно використовувати обережно:

• автоматичне генерування транзакції: її запити будуть охоплені транзакцією
• Незалежність контексту бази даних: її виконання не має нічого спільного context.SaveChanges()

Ці питання можна уникнути, взявши під контроль транзакцію. Наступний код ілюструє способи пакетного видалення та масової вставки транзакційним способом:

var repo = DataAccess.EntityRepository;
var existingData = repo.All.Where(x => x.ParentId == parentId);  

TransactionScope scope = null;
try
{
    // this starts the outer transaction 
    using (scope = new TransactionScope(TransactionScopeOption.Required))
    {
        // this starts and commits an inner transaction
        existingData.Delete();

        // var toInsert = ... 

        // this relies on EntityFramework.BulkInsert library
        repo.BulkInsert(toInsert);

        // any other context changes can be performed

        // this starts and commit an inner transaction
        DataAccess.SaveChanges();

        // this commit the outer transaction
        scope.Complete();
    }
}
catch (Exception exc)
{
    // this also rollbacks any pending transactions
    scope?.Dispose();
}

Ядро Entity Framework

3,1 3,0 2,2 2,1 1,0 1,1 1,0

using (YourContext context = new YourContext ())
{
    var widgets = context.Widgets.Where(w => w.WidgetId == widgetId);
    context.Widgets.RemoveRange(widgets);
    context.SaveChanges();
}

Підсумок :

Вилучає задану колекцію сутностей із контексту, що лежить в основі набору, при цьому кожен об'єкт буде переведений у стан Видаленого, щоб він був видалений із бази даних при виклику SaveChanges.

Зауваження :

Зауважте, що якщо System.Data.Entity.Infrastructure.DbContextConfiguration.AutoDetectChangesEnabled встановлено значення true (що є за замовчуванням), то DetectChanges буде викликано один раз перед видаленням будь-яких об'єктів і більше не буде викликано. Це означає, що в деяких ситуаціях RemoveRange може бути значно кращим, ніж багаторазовий виклик Remove. Зауважте, що якщо будь-яка сутність існує в контексті в стані Доданий, то цей метод призведе до того, що вона буде відмежована від контексту. Це пов’язано з тим, що додана сутність не існує в базі даних, так що намагатися видалити її не має сенсу.

Ви можете виконати запити sql безпосередньо так:

    private int DeleteData()
{
    using (var ctx = new MyEntities(this.ConnectionString))
    {
        if (ctx != null)
        {

            //Delete command
            return ctx.ExecuteStoreCommand("DELETE FROM ALARM WHERE AlarmID > 100");

        }
    }
    return 0;
}

Для вибору ми можемо використовувати

using (var context = new MyContext()) 
{ 
    var blogs = context.MyTable.SqlQuery("SELECT * FROM dbo.MyTable").ToList(); 
}

Ви також можете використовувати метод DeleteAllOnSubmit () , передаючи його результати в загальний список, а не у var. Таким чином ваш передбачення зводиться до одного рядка коду:

List<Widgets> widgetList = context.Widgets
              .Where(w => w.WidgetId == widgetId).ToList<Widgets>();

context.Widgets.DeleteAllOnSubmit(widgetList);

context.SubmitChanges();

Він, ймовірно, все ще використовує цикл всередині.

Відповідь Тхана найкраще працювала для мене. Видалено всі мої записи за один сервер. Я боровся з фактичним викликом методу розширення, тому думав, що поділюсь своїм (EF 6):

Я додав метод розширення до класу помічників у своєму проекті MVC і змінив ім'я на "RemoveWhere". Я ввожу dbContext у свої контролери, але ви також можете зробити це using.

// make a list of items to delete or just use conditionals against fields
var idsToFilter = dbContext.Products
    .Where(p => p.IsExpired)
    .Select(p => p.ProductId)
    .ToList();

// build the expression
Expression<Func<Product, bool>> deleteList = 
    (a) => idsToFilter.Contains(a.ProductId);

// Run the extension method (make sure you have `using namespace` at the top)
dbContext.RemoveWhere(deleteList);

Це генерувало для групи єдиний оператор видалення.

EF 6. =>

var assignmentAddedContent = dbHazirBot.tbl_AssignmentAddedContent.Where(a =>
a.HazirBot_CategoryAssignmentID == categoryAssignment.HazirBot_CategoryAssignmentID);
dbHazirBot.tbl_AssignmentAddedContent.RemoveRange(assignmentAddedContent);
dbHazirBot.SaveChanges();

Кращий: in EF6 => .RemoveRange()

Приклад:

db.Table.RemoveRange(db.Table.Where(x => Field == "Something"));

Дивіться відповідь "улюблений біт коду", який працює

Ось як я ним користувався:

     // Delete all rows from the WebLog table via the EF database context object
    // using a where clause that returns an IEnumerable typed list WebLog class 
    public IEnumerable<WebLog> DeleteAllWebLogEntries()
    {
        IEnumerable<WebLog> myEntities = context.WebLog.Where(e => e.WebLog_ID > 0);
        context.WebLog.RemoveRange(myEntities);
        context.SaveChanges();

        return myEntities;
    }

У EF 6.2 це відмінно працює, надсилаючи видалення безпосередньо в базу даних, не завантажуючи об'єктів:

context.Widgets.Where(predicate).Delete();

З фіксованим присудком це досить просто:

context.Widgets.Where(w => w.WidgetId == widgetId).Delete();

А якщо вам потрібен динамічний предикат, подивіться на LINQKit (пакет Nuget доступний), у моєму випадку щось подібне працює добре:

Expression<Func<Widget, bool>> predicate = PredicateBuilder.New<Widget>(x => x.UserID == userID);
if (somePropertyValue != null)
{
    predicate = predicate.And(w => w.SomeProperty == somePropertyValue);
}
context.Widgets.Where(predicate).Delete();