Bagaimana cara menghapus beberapa baris di Entity Framework (tanpa foreach)

Saya menghapus beberapa item dari tabel menggunakan Entity Framework. Tidak ada objek kunci asing / induk jadi saya tidak bisa menangani ini dengan OnDeleteCascade.

Saat ini saya sedang melakukan ini:

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

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

Ini bekerja tetapi foreach menggangguku. Saya menggunakan EF4 tetapi saya tidak ingin menjalankan SQL. Saya hanya ingin memastikan saya tidak melewatkan apa pun - ini sebagus yang didapat, bukan? Saya bisa abstrak dengan metode ekstensi atau pembantu, tetapi di suatu tempat kita masih akan melakukan foreach, kan?

Jika Anda tidak ingin menjalankan SQL langsung memanggil DeleteObject dalam satu lingkaran adalah yang terbaik yang dapat Anda lakukan hari ini.

Namun Anda dapat menjalankan SQL dan tetap membuatnya menjadi tujuan umum sepenuhnya melalui metode ekstensi, menggunakan pendekatan yang saya jelaskan di sini .

Meskipun jawaban itu untuk 3.5. Untuk 4.0 saya mungkin akan menggunakan API ExecuteStoreCommand baru di bawah tenda, alih-alih turun ke StoreConnection.

EntityFramework 6 membuatnya lebih mudah .RemoveRange() .

Contoh:

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

ini sebagus yang didapat, kan? Saya bisa abstrak dengan metode ekstensi atau pembantu, tetapi di suatu tempat kita masih akan melakukan foreach, kan?

Ya, kecuali Anda bisa membuatnya menjadi dua baris:

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);
}

Saya tahu ini cukup terlambat tetapi jika seseorang membutuhkan solusi sederhana, hal yang keren adalah Anda juga dapat menambahkan klausa di mana dengannya:

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);
}

Catatan: baru diuji dengan MSSQL2008.

Memperbarui:

Solusi di atas tidak akan berfungsi ketika EF menghasilkan pernyataan sql dengan parameter , jadi inilah pembaruan untuk 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);
}

Ini membutuhkan sedikit refleksi tetapi bekerja dengan baik.

Bagi siapa pun yang menggunakan EF5, pustaka ekstensi berikut dapat digunakan: https://github.com/loresoft/EntityFramework.Extended

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

Tampaknya masih gila harus menarik kembali apa pun dari server hanya untuk menghapusnya, tetapi paling tidak mendapatkan kembali ID saja jauh lebih ramping daripada menarik entitas lengkap:

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();
} 

Pemakaian:

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

Or:

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

Untuk EF 4.1,

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

Anda bisa menggunakan ekstensi library untuk melakukannya seperti EntityFramework.Extended atau Z.EntityFramework.Plus.EF6, ada tersedia untuk EF 5, 6 atau Core. Pustaka ini memiliki kinerja yang hebat ketika Anda harus menghapus atau memperbarui dan mereka menggunakan LINQ. Contoh untuk menghapus ( sumber plus ):

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

atau ( sumber diperluas )

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

Ini menggunakan pernyataan SQL asli, jadi kinerjanya bagus.

Cara tercepat untuk menghapus menggunakan prosedur tersimpan. Saya lebih suka prosedur yang tersimpan dalam proyek database daripada SQL dinamis karena penggantian nama akan ditangani dengan benar dan memiliki kesalahan penyusun. SQL dinamis bisa merujuk ke tabel yang telah dihapus / diganti namanya menyebabkan kesalahan waktu berjalan.

Dalam contoh ini, saya memiliki dua Daftar tabel dan Daftar item. Saya perlu cara cepat untuk menghapus semua ListItems dari daftar yang diberikan.

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

Sekarang bagian yang menarik dari menghapus item dan memperbarui kerangka kerja Entity menggunakan ekstensi.

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;
        }
    }
}

Kode utama sekarang dapat menggunakannya adalah sebagai

[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);
    }
}

Jika Anda ingin menghapus semua baris tabel, Anda bisa menjalankan perintah sql

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

TRUNCATE TABLE (Transact-SQL) Menghapus semua baris dari tabel tanpa mencatat penghapusan baris individu. TRUNCATE TABLE mirip dengan pernyataan DELETE tanpa klausa WHERE; Namun, TRUNCATE TABLE lebih cepat dan menggunakan lebih sedikit sumber daya sistem dan log transaksi.

UUHHIVSIni adalah cara yang sangat elegan dan cepat untuk menghapus batch, tetapi harus digunakan dengan hati-hati:

• pembuatan otomatis transaksi: kueri akan diliputi oleh transaksi
• basis data konteks independensi: pelaksanaannya tidak ada hubungannya dengan context.SaveChanges()

Masalah-masalah ini dapat diatasi dengan mengendalikan transaksi. Kode berikut mengilustrasikan bagaimana cara batch batch menghapus dan memasukkan secara transaksional:

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();
}

Inti Kerangka Entitas

3.1 3.0 2.2 2.1 2.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();
}

Ringkasan :

Menghapus koleksi entitas yang diberikan dari konteks yang mendasari set dengan masing-masing entitas dimasukkan ke dalam status Dihapus sehingga akan dihapus dari database ketika SaveChanges dipanggil.

Komentar :

Perhatikan bahwa jika System.Data.Entity.Infrastructure.DbContextConfiguration.AutoDetectChangesEnabled diatur ke true (yang merupakan default), maka DetectChanges akan dipanggil sekali sebelum menghapus entitas apa pun dan tidak akan dipanggil lagi. Ini berarti bahwa dalam beberapa situasi, RemoveRange mungkin berperforma lebih baik daripada memanggil Hapus beberapa kali. Perhatikan bahwa jika ada entitas yang ada dalam konteks di negara Ditambahkan, maka metode ini akan membuatnya terlepas dari konteks. Ini karena entitas yang ditambahkan diasumsikan tidak ada dalam database sehingga mencoba menghapusnya tidak masuk akal.

Anda dapat menjalankan kueri sql secara langsung sebagai berikut:

    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;
}

Untuk pilih kita dapat menggunakan

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

Anda juga dapat menggunakan metode DeleteAllOnSubmit () dengan meneruskannya hasil Anda dalam daftar generik daripada di var. Dengan cara ini, foreach Anda mengurangi menjadi satu baris kode:

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

context.Widgets.DeleteAllOnSubmit(widgetList);

context.SubmitChanges();

Mungkin masih menggunakan loop secara internal.

Jawaban Thanh bekerja paling baik untuk saya. Menghapus semua catatan saya dalam satu perjalanan server. Saya kesulitan benar-benar memanggil metode ekstensi, jadi saya pikir saya akan berbagi milik saya (EF 6):

Saya menambahkan metode ekstensi ke kelas pembantu di proyek MVC saya dan mengubah nama menjadi "RemoveWhere". Saya menyuntikkan dbContext ke dalam pengontrol saya, tetapi Anda juga bisa melakukannya 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);

Ini menghasilkan pernyataan penghapusan tunggal untuk grup.

EF 6. =>

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

Terbaik: in EF6 => .RemoveRange()

Contoh:

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

Lihat jawaban 'bit kode favorit' yang berfungsi

Inilah cara saya menggunakannya:

     // 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;
    }

Di EF 6.2 ini bekerja dengan sempurna, mengirim penghapusan langsung ke database tanpa terlebih dahulu memuat entitas:

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

Dengan predikat tetap, ini cukup mudah:

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

Dan jika Anda memerlukan predikat dinamis, lihat LINQKit (paket Nuget tersedia), sesuatu seperti ini berfungsi dengan baik dalam kasus saya:

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();