Cadre d'entité. Supprimer toutes les lignes du tableau

Comment puis-je supprimer rapidement toutes les lignes du tableau à l'aide d'Entity Framework?

J'utilise actuellement:

var rows = from o in dataDb.Table
           select o;
foreach (var row in rows)
{
    dataDb.Table.Remove(row);
}
dataDb.SaveChanges();

Cependant, son exécution est longue.

Y a-t-il des alternatives?

Pour ceux qui googlent cela et se retrouvent ici comme moi, c'est comme ça que vous le faites actuellement dans EF5 et EF6:

context.Database.ExecuteSqlCommand("TRUNCATE TABLE [TableName]");

En supposant que le contexte est un System.Data.Entity.DbContext

Avertissement: ce qui suit ne convient que pour les petites tables (pensez <1000 lignes)

Voici une solution qui utilise le framework d'entité (pas SQL) pour supprimer les lignes, elle n'est donc pas spécifique à SQL Engine (R / DBM).

Cela suppose que vous effectuez cette opération pour des tests ou une situation similaire. Soit

• La quantité de données est petite ou
• La performance n'a pas d'importance

Appelez simplement:

VotingContext.Votes.RemoveRange(VotingContext.Votes);

En supposant ce contexte:

public class VotingContext : DbContext
{
    public DbSet<Vote> Votes{get;set;}
    public DbSet<Poll> Polls{get;set;}
    public DbSet<Voter> Voters{get;set;}
    public DbSet<Candidacy> Candidates{get;set;}
}

Pour un code plus ordonné, vous pouvez déclarer la méthode d'extension suivante:

public static class EntityExtensions
{
    public static void Clear<T>(this DbSet<T> dbSet) where T : class
    {
        dbSet.RemoveRange(dbSet);
    }
}

Ensuite, ce qui précède devient:

VotingContext.Votes.Clear();
VotingContext.Voters.Clear();
VotingContext.Candidacy.Clear();
VotingContext.Polls.Clear();
await VotingTestContext.SaveChangesAsync();

J'ai récemment utilisé cette approche pour nettoyer ma base de données de test pour chaque exécution de testcase (c'est évidemment plus rapide que de recréer la base de données à chaque fois, bien que je n'ai pas vérifié la forme des commandes de suppression qui ont été générées).

Pourquoi cela peut-il être lent?

1. EF obtiendra TOUTES les lignes (VotingContext.Votes)
2. puis utiliseront leurs identifiants (je ne sais pas exactement comment, peu importe), pour les supprimer.

Donc, si vous travaillez avec une quantité importante de données, vous tuerez le processus du serveur SQL (il consommera toute la mémoire) et la même chose pour le processus IIS car EF mettra en cache toutes les données de la même manière que le serveur SQL. N'utilisez pas celui-ci si votre table contient une quantité importante de données.

L'utilisation de la TRUNCATE TABLEcommande SQL sera la plus rapide car elle opère sur la table et non sur des lignes individuelles.

dataDb.ExecuteStoreCommand("TRUNCATE TABLE [Table]");

En supposant que dataDbc'est un DbContext(pas un ObjectContext), vous pouvez le boucler et utiliser la méthode comme ceci:

var objCtx = ((System.Data.Entity.Infrastructure.IObjectContextAdapter)dataDb).ObjectContext;
objCtx.ExecuteStoreCommand("TRUNCATE TABLE [Table]");

var all = from c in dataDb.Table select c;
dataDb.Table.RemoveRange(all);
dataDb.SaveChanges();

using (var context = new DataDb())
{
     var ctx = ((System.Data.Entity.Infrastructure.IObjectContextAdapter)context).ObjectContext;
     ctx.ExecuteStoreCommand("DELETE FROM [TableName] WHERE Name= {0}", Name);
}

ou

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

Vous pouvez le faire sans Foreach

dataDB.Table.RemoveRange(dataDB.Table);
dataDB.SaveChanges();

Cela supprimera toutes les lignes

Cela évite d'utiliser n'importe quel sql

using (var context = new MyDbContext())
{
    var itemsToDelete = context.Set<MyTable>();
    context.MyTables.RemoveRange(itemsToDelete);
    context.SaveChanges();
}

Je suis tombé sur cette question quand j'ai dû faire face à un cas particulier: la mise à jour complète du contenu dans une table "feuille" (pas de FK pointant dessus). Cela impliquait de supprimer toutes les lignes et de mettre de nouvelles informations sur les lignes et cela devrait être fait de manière transactionnelle (je ne veux pas me retrouver avec une table vide, si les insertions échouent pour une raison quelconque).

J'ai essayé le public static void Clear<T>(this DbSet<T> dbSet) approche, mais de nouvelles lignes ne sont pas insérées. Un autre inconvénient est que l'ensemble du processus est lent, car les lignes sont supprimées une par une.

Je suis donc passé à l' TRUNCATEapproche, car il est beaucoup plus rapide et il est également ROLLBACKable . Il réinitialise également l'identité.

Exemple utilisant un modèle de référentiel:

public class Repository<T> : IRepository<T> where T : class, new()
{
    private readonly IEfDbContext _context;

    public void BulkInsert(IEnumerable<T> entities)
    {
        _context.BulkInsert(entities);
    }

    public void Truncate()
    {
        _context.Database.ExecuteSqlCommand($"TRUNCATE TABLE {typeof(T).Name}");
    }
 }

 // usage 
 DataAccess.TheRepository.Truncate();
 var toAddBulk = new List<EnvironmentXImportingSystem>();

 // fill toAddBulk from source system
 // ...

 DataAccess.TheRepository.BulkInsert(toAddBulk);
 DataAccess.SaveChanges();

Bien sûr, comme déjà mentionné, cette solution ne peut pas être utilisée par des tables référencées par des clés étrangères (TRUNCATE échoue).

si

      using(var db = new MyDbContext())
            {
               await db.Database.ExecuteSqlCommandAsync(@"TRUNCATE TABLE MyTable"););
            }

les causes

Impossible de tronquer la table 'MyTable' car elle est référencée par une contrainte FOREIGN KEY.

J'utilise ceci:

      using(var db = new MyDbContext())
               {
                   await db.Database.ExecuteSqlCommandAsync(@"DELETE FROM MyTable WHERE ID != -1");
               }

var data = (from n in db.users select n);
db.users.RemoveRange(data);
db.SaveChanges();

Si vous souhaitez effacer l'intégralité de votre base de données.

En raison des contraintes de clé étrangère, il importe de savoir dans quelle séquence les tables sont tronquées. C'est un moyen de renforcer brutalement cette séquence.

    public static void ClearDatabase<T>() where T : DbContext, new()
    {
        using (var context = new T())
        {
            var tableNames = context.Database.SqlQuery<string>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' AND TABLE_NAME NOT LIKE '%Migration%'").ToList();
            foreach (var tableName in tableNames)
            {
                foreach (var t in tableNames)
                {
                    try
                    {

                        if (context.Database.ExecuteSqlCommand(string.Format("TRUNCATE TABLE [{0}]", tableName)) == 1)
                            break;

                    }
                    catch (Exception ex)
                    {

                    }
                }
            }

            context.SaveChanges();
        }
    }

usage:

ClearDatabase<ApplicationDbContext>();

n'oubliez pas de réactiver votre DbContext après cela.

Les travaux suivants sur la base de données SQLite (en utilisant Entity Framework)

Il semble que le moyen le plus rapide d'effacer toutes les tables de base de données utilise "context.Database.ExecuteSqlCommand (" certains SQL ")", comme certains commentaires ci-dessus l'ont également souligné. Ici, je vais montrer comment réinitialiser le nombre d'index des tables aussi.

            context.Database.ExecuteSqlCommand("delete from TableA");
            context.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='TableA'");//resets the autoindex

            context.Database.ExecuteSqlCommand("delete from TableB");
            context.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='TableB'");//resets the autoindex 

            context.Database.ExecuteSqlCommand("delete from TableC");
            context.Database.ExecuteSqlCommand("delete from sqlite_sequence where name='TableC'");//resets the autoindex 

Un point important est que si vous utilisez des clés étrangères dans vos tables, vous devez d'abord supprimer la table enfant avant la table parent, de sorte que la séquence (hiérarchie) des tables pendant la suppression est importante, sinon une exception SQLite peut se produire.

Remarque: var context = new YourContext ()

Cela fonctionne correctement dans EF 5:

YourEntityModel myEntities = new YourEntityModel();

var objCtx = ((IObjectContextAdapter)myEntities).ObjectContext;
objCtx.ExecuteStoreCommand("TRUNCATE TABLE [TableName]");

Dans EFCore (la version que j'utilise est 3.1), vous pouvez utiliser ce qui suit pour supprimer toutes les lignes -

context.Database.ExecuteSqlRaw("TRUNCATE TABLE [TableName]");

Supprimez tous les enregistrements. Ne réinitialisez pas l'index primaire comme "tronquer".

/// <summary>
/// SET - DELETE all record by table - no truncate - return deleted records
/// </summary>
public static int setListDelAllMYTABLE()
{
    // INIT
    int retObj = 0;
    using (MYDBEntities ctx = new MYDBEntities())
    {
        // GET - all record
        var tempAllRecord = ctx.MYTABLE.ToList();
        // RESET
        ctx.MYTABLE.RemoveRange(tempAllRecord);
        // SET - final save
        retObj += ctx.SaveChanges();
    }
    // RET
    return retObj;
}

Dans mon code, je n'avais pas vraiment accès à l'objet Database, vous pouvez donc le faire sur le DbSet où vous pouvez également utiliser n'importe quel type de SQL. Cela se terminera en quelque sorte comme ceci:

var p = await _db.Persons.FromSql("truncate table Persons;select top 0 * from Persons").ToListAsync();

Si MVC, vous pouvez faire:

public async Task<IActionResult> DeleteAll()
{
    var list = await _context.YourClass.ToListAsync();
    _context.YourClass.RemoveRange(list);
    await _context.SaveChangesAsync();
    return RedirectToAction(nameof(Index));
}

Assurez-vous que lorsque vous essayez de supprimer le parent, tous les enfants seront mis en cascade lors de la suppression. Ou les enfants ont une clé étrangère nullable.

var list = db.Discounts.ToList().Select(x => x as Discount);
foreach (var item in list)
{
    db.Discounts.Remove(item);
}
db.SaveChanges();