Entity Framework'teki birden çok satırı nasıl silebilirim (foreach olmadan)

Entity Framework kullanarak bir tablodan birkaç öğe siliyorum. Yabancı bir anahtar / üst nesne yok, bu yüzden OnDeleteCascade ile bu işleyemezsiniz.

Şu anda bunu yapıyorum:

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

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

Çalışıyor ama foreach beni rahatsız ediyor. EF4 kullanıyorum ama SQL yürütmek istemiyorum. Ben sadece bir şey eksik olmadığından emin olmak istiyorum - bu kadar iyi, değil mi? Bir uzatma yöntemi veya yardımcısı ile soyutlayabilirim, ancak bir yerde hala bir foreach yapacağız, değil mi?

SQL'i doğrudan bir döngüde DeleteObject'i çağırmak istemiyorsanız, bugün yapabileceğiniz en iyisidir.

Bununla birlikte, burada açıkladığım yaklaşımı kullanarak SQL'yi yürütebilir ve yine de bir uzantı yöntemi aracılığıyla tamamen genel bir amaç haline getirebilirsiniz .

Her ne kadar bu cevap 3.5 idi. 4.0 için StoreConnection'a gitmek yerine büyük olasılıkla yeni ExecuteStoreCommand API'sini kullanacağım.

EntityFramework 6 bunu biraz daha kolaylaştırdı .RemoveRange().

Misal:

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

bu kadar iyi, değil mi? Bir uzatma yöntemi veya yardımcısı ile soyutlayabilirim, ancak bir yerde hala bir foreach yapacağız, değil mi?

Evet, ancak iki astarlı yapabilirsiniz:

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

Oldukça geç olduğunu biliyorum, ancak birinin basit bir çözüme ihtiyacı varsa, havalı şey de onunla nerede maddeyi ekleyebilirsiniz:

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

Not: MSSQL2008 ile test edilmiştir.

Güncelleme:

EF, parametrelerle sql deyimi oluşturduğunda yukarıdaki çözüm çalışmaz , bu nedenle EF5 için güncelleme :

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

Biraz yansıma gerektirir, ancak iyi çalışır.

EF5 kullanan herkes için aşağıdaki uzantı kitaplığı kullanılabilir: https://github.com/loresoft/EntityFramework.Extended

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

Yine de silmek için sunucudan herhangi bir şey geri almak zorunda olmak çılgınca görünüyor, ancak en azından sadece kimlikleri geri almak, tüm varlıkları aşağı çekmekten çok daha zayıf:

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

Kullanımı:

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

Or:

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

EF 4.1 için,

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

Bunu yapmak için EntityFramework.Extended veya Z.EntityFramework.Plus.EF6 gibi uzantı kütüphanelerini kullanabilirsiniz, EF 5, 6 veya Core için kullanılabilir. Bu kütüphaneler, silmeniz veya güncellemeniz gerektiğinde mükemmel performans gösterir ve LINQ kullanır. Silme örneği ( kaynak artı ):

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

veya ( kaynak genişletildi )

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

Bunlar yerel SQL ifadeleri kullanır, bu nedenle performans mükemmeldir.

Silmenin en hızlı yolu saklı bir yordam kullanmaktır. Dinamik SQL yerine bir veritabanı projesinde saklı yordamlar tercih çünkü isimleri doğru ele alınacak ve derleyici hataları var. Dinamik SQL, çalışma zamanı hatalarına neden olan silinen / yeniden adlandırılan tablolara başvurabilir.

Bu örnekte, List ve ListItems adlı iki tablo var. Belirli bir listenin tüm ListItems silmek için hızlı bir yol gerekir.

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

Şimdi öğeleri silmenin ve Varlık çerçevesini bir uzantı kullanarak güncellemenin ilginç kısmı.

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

Ana kod şimdi kullanabilirsiniz gibi

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

Bir tablonun tüm satırlarını silmek istiyorsanız, sql komutunu yürütebilirsiniz

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

TRUNCATE TABLE (Transact-SQL) Tek tek satır silme işlemlerini kaydetmeden tablodaki tüm satırları kaldırır. TRUNCATE TABLE, WHERE deyimi olmayan DELETE deyimine benzer; ancak, TRUNCATE TABLE daha hızlıdır ve daha az sistem ve işlem günlüğü kaynağı kullanır.

UUHHIVS's, toplu silme için çok zarif ve hızlı bir yoldur, ancak dikkatli kullanılmalıdır:

• otomatik işlem oluşturma: sorguları bir işlem tarafından kapsanacaktır
• veritabanı bağlam bağımsızlığı: yürütme ile ilgisi yoktur context.SaveChanges()

Bu sorunlar, işlemin kontrolünü ele alarak atlatılabilir. Aşağıdaki kod, toplu silme ve toplu ekleme işlemlerini nasıl gerçekleştireceğinizi gösterir:

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

Varlık Çerçevesi Çekirdeği

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

Özet :

Verilen varlık koleksiyonunu, SaveChanges çağrıldığında her bir varlık Silinmiş durumuna konacak şekilde kümenin altındaki bağlamdan kaldırır.

Açıklamalar :

System.Data.Entity.Infrastructure.DbContextConfiguration.AutoDetectChangesEnabled öğesi true (varsayılan değer) olarak ayarlanırsa, DetectChanges öğelerin silinmeden önce bir kez çağrılacağını ve bir daha çağrılmayacağını unutmayın. Bu, bazı durumlarda RemoveRange işlevinin birden çok kez Kaldır çağrısından çok daha iyi performans gösterebileceği anlamına gelir. Eklenen durumda bağlamda herhangi bir varlık varsa, bu yöntemin söz konusu öğenin bağlamdan ayrılmasına neden olacağını unutmayın. Bunun nedeni, eklenen bir varlığın veritabanında silinmeye çalışılmasının mantıklı olmayacağı şekilde varsayıldığıdır.

Doğrudan sql sorgularını aşağıdaki gibi yürütebilirsiniz:

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

Seçmek için kullanabiliriz

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

Sonuçlarınızı var yerine genel bir listeye ileterek DeleteAllOnSubmit () yöntemini de kullanabilirsiniz . Bu şekilde ön kodunuz bir kod satırına düşer:

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

context.Widgets.DeleteAllOnSubmit(widgetList);

context.SubmitChanges();

Muhtemelen hala dahili olarak bir döngü kullanıyor.

Thanh'ın cevabı benim için en iyi sonucu verdi. Tüm kayıtlarımı tek bir sunucu gezisinde sildim. Aslında uzatma yöntemini çağırmakla uğraştım, bu yüzden benimkini paylaşacağımı düşündüm (EF 6):

MVC projemdeki bir yardımcı sınıfa genişletme yöntemini ekledim ve adı "RemoveWhere" olarak değiştirdim. Denetleyicilerime bir dbContext enjekte ediyorum, ancak bir de yapabilirsiniz 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);

Bu, grup için tek bir silme ifadesi oluşturdu.

EF 6. =>

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

En iyi : in EF6 => .RemoveRange()

Misal:

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

Çalışan 'favori kod parçası' cevabına bakın

İşte nasıl kullandım:

     // 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'de bu mükemmel bir şekilde çalışır ve silmeyi önce varlıkları yüklemeden doğrudan veritabanına gönderir:

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

Sabit bir yüklem ile oldukça basittir:

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

Ve dinamik bir yüklemeye ihtiyacınız varsa LINQKit'e (Nuget paketi mevcut) bir göz atın , böyle bir şey benim durumumda iyi çalışır:

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