Entity Framework. Löschen Sie alle Zeilen in der Tabelle

Wie kann ich mit Entity Framework schnell alle Zeilen in der Tabelle entfernen?

Ich benutze derzeit:

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

Die Ausführung dauert jedoch lange.

Gibt es Alternativen?

Für diejenigen, die dies googeln und wie ich hier gelandet sind, ist dies derzeit in EF5 und EF6 der Fall:

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

Angenommen, der Kontext ist a System.Data.Entity.DbContext

Warnung: Das Folgende ist nur für kleine Tabellen geeignet (denken Sie an <1000 Zeilen).

Hier ist eine Lösung, die das Entity Framework (nicht SQL) zum Löschen der Zeilen verwendet, sodass sie nicht SQL Engine (R / DBM) -spezifisch ist.

Dies setzt voraus, dass Sie dies zum Testen oder in einer ähnlichen Situation tun. Entweder

• Die Datenmenge ist gering oder
• Die Leistung spielt keine Rolle

Rufen Sie einfach an:

VotingContext.Votes.RemoveRange(VotingContext.Votes);

Unter der Annahme dieses Kontextes:

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

Für aufgeräumten Code können Sie die folgende Erweiterungsmethode deklarieren:

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

Dann wird das Obige:

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

Ich habe diesen Ansatz kürzlich verwendet, um meine Testdatenbank für jeden Testfalllauf zu bereinigen (es ist offensichtlich schneller, als die Datenbank jedes Mal von Grund auf neu zu erstellen, obwohl ich die Form der generierten Löschbefehle nicht überprüft habe).

Warum kann es langsam sein?

1. EF erhält ALLE Zeilen (VotingContext.Votes)
2. und verwenden dann ihre IDs (nicht sicher, wie, egal), um sie zu löschen.

Wenn Sie also mit einer großen Datenmenge arbeiten, beenden Sie den SQL Server-Prozess (er verbraucht den gesamten Speicher) und das Gleiche für den IIS-Prozess, da EF alle Daten auf die gleiche Weise wie SQL Server zwischenspeichert. Verwenden Sie diese nicht, wenn Ihre Tabelle ernsthafte Datenmengen enthält.

Die Verwendung des SQL- TRUNCATE TABLEBefehls ist am schnellsten, da er für die Tabelle und nicht für einzelne Zeilen ausgeführt wird.

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

Angenommen, es dataDbist ein DbContext(kein ObjectContext), können Sie es einpacken und die folgende Methode verwenden:

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

oder

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

Sie können das ohne Foreach tun

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

Dadurch werden alle Zeilen entfernt

Dadurch wird die Verwendung von SQL vermieden

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

Ich bin auf diese Frage gestoßen, als ich mich mit einem bestimmten Fall befassen musste: Vollständige Aktualisierung des Inhalts in einer "Blatt" -Tabelle (keine darauf zeigenden FKs). Dies beinhaltete das Entfernen aller Zeilen und das Einfügen neuer Zeileninformationen und sollte transaktional erfolgen (ich möchte nicht mit einer leeren Tabelle enden, wenn Einfügungen aus irgendeinem Grund fehlschlagen).

Ich habe das versucht public static void Clear<T>(this DbSet<T> dbSet) Ansatz , aber neue Zeilen werden nicht eingefügt. Ein weiterer Nachteil ist, dass der gesamte Prozess langsam ist, da die Zeilen einzeln gelöscht werden.

Also habe ich auf TRUNCATEAnnäherung umgestellt , da es viel schneller und auch ROLLBACKable ist . Es setzt auch die Identität zurück.

Beispiel mit Repository-Muster:

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

Wie bereits erwähnt, kann diese Lösung natürlich nicht von Tabellen verwendet werden, auf die durch Fremdschlüssel verwiesen wird (TRUNCATE schlägt fehl).

wenn

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

Ursachen

Die Tabelle 'MyTable' kann nicht abgeschnitten werden, da sie durch eine FOREIGN KEY-Einschränkung referenziert wird.

Ich benutze das :

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

Wenn Sie Ihre gesamte Datenbank löschen möchten.

Aufgrund der Fremdschlüsseleinschränkungen ist es wichtig, in welcher Reihenfolge die Tabellen abgeschnitten werden. Dies ist eine Möglichkeit, diese Sequenz brutal zu erzwingen.

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

Verwendung:

ClearDatabase<ApplicationDbContext>();

Denken Sie daran, Ihren DbContext danach erneut zu installieren.

Das Folgende funktioniert in der SQLite-Datenbank (unter Verwendung von Entity Framework).

Es scheint, dass der schnellste Weg, alle DB-Tabellen zu löschen, die Verwendung von 'context.Database.ExecuteSqlCommand ("some SQL")' ist, wie einige der obigen Kommentare ebenfalls hervorheben. Hier werde ich zeigen, wie man auch die 'Index'-Anzahl von Tabellen zurücksetzt.

            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 

Ein wichtiger Punkt ist, dass Sie, wenn Sie Fremdschlüssel in Ihren Tabellen verwenden, zuerst die untergeordnete Tabelle vor der übergeordneten Tabelle löschen müssen. Daher ist die Reihenfolge (Hierarchie) der Tabellen während des Löschens wichtig, da sonst eine SQLite-Ausnahme auftreten kann.

Hinweis: var context = new YourContext ()

Dies funktioniert ordnungsgemäß in EF 5:

YourEntityModel myEntities = new YourEntityModel();

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

In EFCore (Version, die ich verwende, ist 3.1) können Sie Folgendes verwenden, um alle Zeilen zu entfernen:

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

Löschen Sie alle Datensätze. Setzen Sie den Primärindex nicht wie "Abschneiden" zurück.

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

In meinem Code hatte ich keinen wirklich guten Zugriff auf das Datenbankobjekt, daher können Sie dies auf dem DbSet tun, wo Sie auch jede Art von SQL verwenden dürfen. Es wird so enden:

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

Wenn MVC, können Sie:

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

Stellen Sie sicher, dass beim Löschen des übergeordneten Elements alle untergeordneten Elemente beim Löschen kaskadiert werden. Oder Kinder haben einen nullbaren Fremdschlüssel.

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