Comment puis-je supprimer plusieurs lignes dans le cadre de L'entité (sans foreach)

Entitefram Framework 6 a rendu cela un peu plus facile avec .RemoveRange() .

exemple:

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

c'est aussi bon qu'il obtient, droit? Je peux l'abstraire avec une extension méthode ou aide, mais quelque part nous allons encore faire foreach, droit?

Eh bien, oui, sauf que vous pouvez en faire une double doublure:

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

je sais qu'il est assez tard, mais si quelqu'un a besoin d'une solution simple, la chose cool est que vous pouvez également ajouter la clause où avec elle:

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

Note: vient d'être testé avec MSSQL2008.

mise à Jour: La solution ci-dessus ne fonctionnera pas lorsque EF génère une déclaration sql avec paramètres , donc voici la mise à jour pour 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);
        }

il exige un peu de Réflexion, mais fonctionne bien.

pour toute personne utilisant EF5, la bibliothèque d'extension suivante peut être utilisée: https://github.com/loresoft/EntityFramework.Extended

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

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

Utilisation:

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

Or:

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

semble toujours fou de devoir retirer quoi que ce soit du serveur juste pour l'effacer, mais au moins récupérer juste les IDs est beaucoup plus mince que de tirer vers le bas les entities complètes:

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

pour EF 4.1,

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

le moyen le plus rapide de supprimer est d'utiliser une procédure stockée. Je préfère les procédures stockées dans un projet de base de données au SQL dynamique parce que les renommages seront manipulés correctement et auront des erreurs de compilation. Le SQL dynamique peut se référer à des tables qui ont été supprimées/renommées et qui causent des erreurs de temps d'exécution.

dans cet exemple, j'ai deux tables List et ListItems. J'ai besoin d'un moyen rapide pour supprimer tous les ListItems d'une liste donnée.

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

maintenant le partie intéressante de la suppression des éléments et de la mise à jour du cadre de L'entité à l'aide d'une extension.

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

le code principal peut maintenant l'utiliser est comme

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

Si vous souhaitez supprimer toutes les lignes d'une table, vous pouvez exécuter la commande sql

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

table tronquée (Transact-SQL) supprime toutes les lignes d'une table sans journaliser les suppressions de ligne individuelles. Le tableau tronqué est similaire à L'énoncé de suppression sans clause où; cependant, le tableau tronqué est plus rapide et utilise moins de ressources du système et du journal des transactions.

vous pouvez utiliser les bibliothèques extensions pour faire cela comme Entitefram Framework.Étendue ou Z. Entitefram Framework.Majoré.EF6, disponible pour EF 5, 6 ou Core. Ces bibliothèques ont de bonnes performances lorsque vous devez supprimer ou mettre à jour et QU'elles utilisent LINQ. Exemple de suppression ( source plus ):

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

, ou source étendue )

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

ceux-ci utilisent des énoncés SQL natifs, donc la performance est grande.

vous pouvez exécuter des requêtes sql directement comme suit:

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

pour sélectionner nous pouvons utiliser

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

vous pouvez également utiliser la méthode DeleteAllOnSubmit () en lui passant vos résultats dans une liste générique plutôt que dans var. Ainsi votre foreach se réduit à une ligne de code:

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

context.Widgets.DeleteAllOnSubmit(widgetList);

context.SubmitChanges();

il utilise probablement encore une boucle en interne cependant.

UUHHIVS 's est un moyen très élégant et rapide pour supprimer par lots, mais il doit être utilisé avec soin:

• génération automatique de transaction: ses requêtes seront couvertes par une transaction
• indépendance du contexte de la base de données: son exécution n'a rien à voir avec context.SaveChanges()

ces émissions peuvent être contournées en prenant le contrôle de la transaction. Le code suivant illustre comment supprimer et insérer en vrac de manière transactionnelle:

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

EF 6.= >

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

voir la réponse "bit de code préféré" qui fonctionne

Voici comment je l'ai utilisé:

     // 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 EF6 => .RemoveRange()

exemple:

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

 int id = 5;
 db.tablename.RemoveRange(db.tablename.Where(c => c.firstid == id));