Entity Framework. Elimina tutte le righe nella tabella

Come posso rimuovere rapidamente tutte le righe nella tabella usando Entity Framework?

Attualmente sto usando:

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

Tuttavia, l'esecuzione richiede molto tempo.

Ci sono alternative?

Per quelli che stanno cercando su Google e sono finiti qui come me, ecco come lo fai attualmente in EF5 ed EF6:

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

Supponendo che il contesto sia a System.Data.Entity.DbContext

Avvertenza: quanto segue è adatto solo per piccole tabelle (si pensi a <1000 righe)

Ecco una soluzione che utilizza il framework di entità (non SQL) per eliminare le righe, quindi non è specifico di SQL Engine (R / DBM).

Questo presuppone che tu lo stia facendo per un test o una situazione simile. O

• La quantità di dati è piccola o
• Le prestazioni non contano

Chiama semplicemente:

VotingContext.Votes.RemoveRange(VotingContext.Votes);

Supponendo questo contesto:

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

Per il codice più ordinato puoi dichiarare il seguente metodo di estensione:

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

Quindi quanto sopra diventa:

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

Recentemente ho usato questo approccio per ripulire il mio database di test per ogni esecuzione di testcase (ovviamente è più veloce che ricreare il DB da capo ogni volta, anche se non ho controllato la forma dei comandi di eliminazione che sono stati generati).

Perché può essere lento?

1. EF otterrà TUTTE le righe (VotingContext.Votes)
2. e poi useranno i loro ID (non sono sicuro di come, non importa), per eliminarli.

Quindi, se stai lavorando con una grande quantità di dati, ucciderai il processo del server SQL (consumerà tutta la memoria) e la stessa cosa per il processo IIS poiché EF memorizzerà nella cache tutti i dati allo stesso modo del server SQL. Non usare questo se la tua tabella contiene una grande quantità di dati.

L'uso del TRUNCATE TABLEcomando SQL sarà il più veloce in quanto opera sulla tabella e non su singole righe.

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

Supponendo che dataDbsia un DbContext(non un ObjectContext), puoi avvolgerlo e usare il metodo in questo modo:

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

o

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

Puoi farlo senza Foreach

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

Questo rimuoverà tutte le righe

Questo evita di usare qualsiasi sql

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

Mi sono imbattuto in questa domanda quando ho dovuto affrontare un caso particolare: l'aggiornamento completo dei contenuti in una tabella "foglia" (nessun FK che lo indica). Ciò ha comportato la rimozione di tutte le righe e l'inserimento di nuove informazioni sulle righe e dovrebbe essere eseguito in modo transazionale (non voglio finire con una tabella vuota, se gli inserimenti falliscono per qualsiasi motivo).

Ho provato il public static void Clear<T>(this DbSet<T> dbSet) approccio, ma non sono state inserite nuove righe. Un altro svantaggio è che l'intero processo è lento, poiché le righe vengono eliminate una per una.

Quindi, sono passato TRUNCATEall'approccio, poiché è molto più veloce ed è anche ROLLBACKable . Ripristina anche l'identità.

Esempio utilizzando il modello di repository:

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

Naturalmente, come già accennato, questa soluzione non può essere utilizzata dalle tabelle a cui fanno riferimento chiavi esterne (TRUNCATE ha esito negativo).

Se

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

cause

Impossibile troncare la tabella "MyTable" perché a cui fa riferimento un vincolo FOREIGN KEY.

Io lo uso questo:

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

Se si desidera cancellare l'intero database.

A causa dei vincoli di chiave esterna è importante quale sequenza le tabelle vengono troncate. Questo è un modo per rinforzare questa sequenza.

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

utilizzo:

ClearDatabase<ApplicationDbContext>();

ricorda di reintegrare il tuo DbContext dopo questo.

Il seguente funziona sul database SQLite (usando Entity Framework)

Sembra che il modo più veloce per cancellare tutte le tabelle db sia usare 'context.Database.ExecuteSqlCommand ("some SQL")', come anche alcuni commenti sopra evidenziati. Qui ho intenzione di mostrare come reimpostare anche il conteggio 'indice' delle tabelle.

            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 punto importante è che se si utilizzano chiavi esterne nelle tabelle, è necessario prima eliminare la tabella figlio prima della tabella padre, quindi la sequenza (gerarchia) delle tabelle durante l'eliminazione è importante, altrimenti potrebbe verificarsi un'eccezione SQLite.

Nota: var context = new YourContext ()

Funziona correttamente in EF 5:

YourEntityModel myEntities = new YourEntityModel();

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

In EFCore (la versione che sto usando è la 3.1) puoi usare quanto segue per rimuovere tutte le righe -

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

Elimina tutti i record. Non ripristinare l'indice primario come "troncare".

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

Nel mio codice non avevo davvero un buon accesso all'oggetto Database, quindi puoi farlo sul DbSet dove puoi anche usare qualsiasi tipo di sql. Finirà in questo modo:

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

Se MVC, puoi fare:

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

Assicurarsi che quando si sta tentando di eliminare un genitore, tutti i bambini si sovrapporranno all'eliminazione. O i bambini hanno una chiave esterna nullable.

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