Wie lösche ich mehrere Zeilen in Entity Framework (ohne foreach)

Ich lösche mehrere Elemente mit Entity Framework aus einer Tabelle. Es gibt keinen Fremdschlüssel / übergeordnetes Objekt, daher kann ich dies mit OnDeleteCascade nicht verarbeiten.

Im Moment mache ich das:

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

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

Es funktioniert, aber der Foreach nervt mich. Ich verwende EF4, möchte aber kein SQL ausführen. Ich möchte nur sicherstellen, dass mir nichts entgeht - das ist so gut wie es nur geht, oder? Ich kann es mit einer Erweiterungsmethode oder einem Helfer abstrahieren, aber irgendwo machen wir immer noch einen Foreach, oder?

Wenn Sie SQL nicht direkt ausführen möchten, ist das Aufrufen von DeleteObject in einer Schleife das Beste, was Sie heute tun können.

Sie können SQL jedoch ausführen und es dennoch über eine Erweiterungsmethode ganz allgemein verwenden, indem Sie den hier beschriebenen Ansatz verwenden .

Obwohl diese Antwort für 3.5 war. Für 4.0 würde ich wahrscheinlich die neue ExecuteStoreCommand-API unter der Haube verwenden, anstatt auf StoreConnection zuzugreifen.

EntityFramework 6 hat dies mit etwas einfacher gemacht .RemoveRange().

Beispiel:

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

das ist so gut wie es nur geht, oder? Ich kann es mit einer Erweiterungsmethode oder einem Helfer abstrahieren, aber irgendwo machen wir immer noch einen Foreach, oder?

Nun ja, außer Sie können es zu einem Zweiliner machen:

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

Ich weiß, dass es ziemlich spät ist, aber falls jemand eine einfache Lösung benötigt, ist das Coole, dass Sie auch die where-Klausel hinzufügen können:

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

Hinweis: gerade mit MSSQL2008 getestet.

Aktualisieren:

Die obige Lösung funktioniert nicht, wenn EF eine SQL-Anweisung mit Parametern generiert. Hier ist das Update für 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);
}

Es erfordert ein wenig Nachdenken, funktioniert aber gut.

Für alle Benutzer von EF5 kann die folgende Erweiterungsbibliothek verwendet werden: https://github.com/loresoft/EntityFramework.Extended

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

Es scheint immer noch verrückt zu sein, etwas vom Server zurückziehen zu müssen, um es zu löschen, aber zumindest die IDs zurückzubekommen, ist viel schlanker als das Abrufen der vollständigen Entitäten:

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

Verwendungszweck:

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

Or:

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

Für EF 4.1

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

Sie können dafür Erweiterungsbibliotheken wie EntityFramework.Extended oder Z.EntityFramework.Plus.EF6 verwenden, die für EF 5, 6 oder Core verfügbar sind. Diese Bibliotheken bieten eine hervorragende Leistung, wenn Sie sie löschen oder aktualisieren müssen, und sie verwenden LINQ. Beispiel zum Löschen ( Quelle plus ):

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

oder ( Quelle erweitert )

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

Diese verwenden native SQL-Anweisungen, sodass die Leistung großartig ist.

Der schnellste Weg zum Löschen ist die Verwendung einer gespeicherten Prozedur. Ich bevorzuge gespeicherte Prozeduren in einem Datenbankprojekt gegenüber dynamischem SQL, da Umbenennungen korrekt behandelt werden und Compilerfehler auftreten. Dynamic SQL kann auf Tabellen verweisen, die gelöscht / umbenannt wurden und Laufzeitfehler verursachen.

In diesem Beispiel habe ich zwei Tabellen List und ListItems. Ich brauche einen schnellen Weg, um alle ListItems einer bestimmten Liste zu löschen.

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

Nun der interessante Teil des Löschens der Elemente und des Aktualisierens des Entity-Frameworks mithilfe einer Erweiterung.

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

Der Hauptcode kann es jetzt wie folgt verwenden

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

Wenn Sie alle Zeilen einer Tabelle löschen möchten, können Sie den Befehl sql ausführen

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

TRUNCATE TABLE (Transact-SQL) Entfernt alle Zeilen aus einer Tabelle, ohne die einzelnen Zeilenlöschungen zu protokollieren. TRUNCATE TABLE ähnelt der DELETE-Anweisung ohne WHERE-Klausel. TRUNCATE TABLE ist jedoch schneller und benötigt weniger System- und Transaktionsprotokollressourcen.

UUHHIVS's ist eine sehr elegante und schnelle Methode zum Löschen von Stapeln, die jedoch mit Vorsicht verwendet werden muss:

• Automatische Generierung von Transaktionen: Die Abfragen werden von einer Transaktion erfasst
• Unabhängigkeit des Datenbankkontexts: Die Ausführung hat nichts damit zu tun context.SaveChanges()

Diese Probleme können umgangen werden, indem die Kontrolle über die Transaktion übernommen wird. Der folgende Code veranschaulicht das Batch-Löschen und Masseneinfügen auf transaktionale Weise:

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 Core

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

Zusammenfassung :

Entfernt die angegebene Sammlung von Entitäten aus dem Kontext, der der Gruppe zugrunde liegt, wobei jede Entität in den Status "Gelöscht" versetzt wird, sodass sie beim Aufruf von SaveChanges aus der Datenbank gelöscht wird.

Anmerkungen :

Beachten Sie, dass DetectChanges vor dem Löschen von Entitäten einmal aufgerufen und nicht erneut aufgerufen wird, wenn System.Data.Entity.Infrastructure.DbContextConfiguration.AutoDetectChangesEnabled auf true gesetzt ist (dies ist die Standardeinstellung). Dies bedeutet, dass RemoveRange in einigen Situationen möglicherweise eine deutlich bessere Leistung erbringt als ein mehrmaliger Aufruf von Remove. Beachten Sie, dass, wenn im Kontext Hinzugefügt eine Entität im Kontext vorhanden ist, diese Methode dazu führt, dass sie vom Kontext getrennt wird. Dies liegt daran, dass davon ausgegangen wird, dass eine hinzugefügte Entität nicht in der Datenbank vorhanden ist, sodass der Versuch, sie zu löschen, keinen Sinn ergibt.

Sie können SQL-Abfragen wie folgt direkt ausführen:

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

Für die Auswahl können wir verwenden

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

Sie können auch die DeleteAllOnSubmit () -Methode verwenden, indem Sie Ihre Ergebnisse in einer generischen Liste anstatt in var übergeben. Auf diese Weise reduziert sich Ihr foreach auf eine Codezeile:

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

context.Widgets.DeleteAllOnSubmit(widgetList);

context.SubmitChanges();

Wahrscheinlich wird intern immer noch eine Schleife verwendet.

Thanhs Antwort funktionierte am besten für mich. Alle meine Datensätze in einer einzigen Serverreise gelöscht. Ich hatte Probleme damit, die Erweiterungsmethode tatsächlich aufzurufen, und dachte, ich würde meine teilen (EF 6):

Ich habe die Erweiterungsmethode einer Hilfsklasse in meinem MVC-Projekt hinzugefügt und den Namen in "RemoveWhere" geändert. Ich füge einen dbContext in meine Controller ein, aber Sie können auch einen ausführen 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);

Dies erzeugte eine einzelne Löschanweisung für die Gruppe.

EF 6. =>

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

Beste : in EF6 => .RemoveRange()

Beispiel:

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

Siehe die Antwort "Lieblingscode", die funktioniert

So habe ich es benutzt:

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

In EF 6.2 funktioniert dies einwandfrei, indem der Löschvorgang direkt an die Datenbank gesendet wird, ohne zuvor die Entitäten zu laden:

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

Mit einem festen Prädikat ist es ganz einfach:

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

Und wenn Sie ein dynamisches Prädikat benötigen, schauen Sie sich LINQKit (Nuget-Paket verfügbar) an. In meinem Fall funktioniert so etwas gut:

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