Massenlöschen in LINQ to Entities

Gibt es eine Möglichkeit, eine Reihe von Objekten, die mit einer bestimmten Abfrage in LINQ oder LINQ-to-Entities übereinstimmen, in großen Mengen zu löschen? Die einzigen Referenzen, die ich finden kann, sind veraltet, und es scheint albern, alle Objekte, die ich entfernen möchte, zu durchlaufen und manuell zu löschen.

Die Frage ist alt (vor EF5). Für alle, die EF5 verwenden, erledigt EntityFramework.Extended dies im Handumdrehen .

Vor einiger Zeit habe ich eine vierteilige Blogserie (Teile 1 , 2 , 3 und 4 ) geschrieben, in der es darum geht, Massenaktualisierungen (mit einem Befehl) im Entity Framework durchzuführen.

Während der Schwerpunkt dieser Serie auf der Aktualisierung lag, konnten Sie die Prinzipien definitiv zum Löschen verwenden.

Sie sollten also in der Lage sein, so etwas zu schreiben:

var query = from c in ctx.Customers
            where c.SalesPerson.Email == "..."
            select c;

query.Delete();

Sie müssen lediglich die Erweiterungsmethode Delete () implementieren. In der Beitragsreihe finden Sie Hinweise, wie ...

Hoffe das hilft

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

Die Antworten, die ich hier sehe, sind Linq to Sql

DeleteAllOnSubmit ist Teil von System.Data.Linq und ITable (Linq to Sql)

Dies ist mit Entity Framework nicht möglich.

Trotzdem habe ich noch keine Lösung, werde aber zurückschreiben, wenn ich das tue

Für diejenigen, die EF6 verwenden und eine Zeilen-SQL-Abfrage zum Löschen ausführen möchten:

using (var context = new DatabaseEntities())
{
    // delete existing records
    context.Database.ExecuteSqlCommand("DELETE FROM YOURTABLE WHERE CustomerID = @id", idParameter);
}

RemoveRange wurde in EF6 eingeführt und kann eine Liste von Objekten entfernen. Super einfach.

var origins= (from po in db.PermitOrigins where po.PermitID == thisPermit.PermitID select po).ToList();
db.PermitOrigins.RemoveRange(origins);
db.SaveChanges();

Ich kenne die DeleteAllOnSubmit- Methode für jeden Datenkontext, der alle Datensätze in der Abfrage löscht. Es muss eine Optimierung zugrunde liegen, da viele Objekte gelöscht werden. Ich bin mir allerdings nicht sicher.

Ich bin mir nicht sicher, wie effizient es wäre, aber Sie könnten so etwas ausprobieren:

// deletes all "People" with the name "Joe"
var mypeople = from p in myDataContext.People
               where p.Name == "Joe";
               select p;
myDataContext.People.DeleteAllOnSubmit(mypeople);
myDataContext.SubmitChanges();

Sie könnten einen gespeicherten Prozess schreiben, der das Löschen ausführt, und ihn von LINQ aus aufrufen. Ein satzbasiertes Löschen ist wahrscheinlich insgesamt schneller. Wenn jedoch zu viele Datensätze betroffen sind, können Sperrprobleme auftreten, und Sie benötigen möglicherweise eine Mischung aus Durchlaufen von Datensatzgruppen (möglicherweise 2000 gleichzeitig, die Größe hängt von Ihrem Datenbankdesign ab, 2000 ist jedoch eine Startort, wenn Sie feststellen, dass das satzbasierte Löschen so lange dauert, dass es die andere Verwendung der Tabelle beeinflusst, um das Löschen durchzuführen.

Das Löschen von Daten über das Entity Framework basiert auf der Verwendung der DeleteObject-Methode. Sie können diese Methode in der EntityCollection für die zu löschende Entitätsklasse oder im abgeleiteten ObjectContext aufrufen. Hier ist ein einfaches Beispiel:

NorthwindEntities db = new NorthwindEntities();

IEnumerable<Order_Detail> ods = from o in db.Order_Details
                                where o.OrderID == 12345                                    
                                select o;

foreach (Order_Detail od in ods) 
    db.Order_Details.DeleteObject(od);

db.SaveChanges();

In diesem Beispiel werden die Datensätze gelöscht, und nacheinander werden sie an die Ergebnismenge angehängt. Anschließend werden sie entfernt. Dann habe ich 1 Änderungen gespeichert.

    using (BillingDB db = new BillingDB())
    {
      var recordsToDelete = (from i in db.sales_order_item
                  where i.sales_order_id == shoppingCartId
                  select i).ToList<sales_order_item>();

      if(recordsToDelete.Count > 0)
      {
        foreach (var deleteSalesOrderItem in recordsToDelete)
        {                  
            db.sales_order_item.Attach(deleteSalesOrderItem);
            db.sales_order_item.Remove(deleteSalesOrderItem);                  
        }
        db.SaveChanges();
      } 
    }

 context.Entity.Where(p => p.col== id)
               .ToList().ForEach(p => db.Entity.DeleteObject(p));

Dies ist die schnellste Methode zum Löschen von Datensätzen aus der Datenbank mithilfe von EF

Ich würde so etwas tun wie:

var recordsToDelete = (from c in db.Candidates_T where c.MyField == null select c).ToList<Candidates_T>();
if(recordsToDelete.Count > 0)
{
    foreach(var record in recordsToDelete)
    {
        db.Candidate_T.DeleteObject(record);
        db.SaveChanges();
    }
}   

Ich glaube nicht, dass es eine Möglichkeit gibt, dies ohne Schleife zu tun, da Entity Framework mit Entities zusammenarbeitet. Meistens bedeutet dies das Sammeln von Objekten.