Marco de la entidad. Eliminar todas las filas en la tabla

¿Cómo puedo eliminar rápidamente todas las filas de la tabla con Entity Framework?

Actualmente estoy usando:

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

Sin embargo, lleva mucho tiempo ejecutarlo.

¿Hay alguna alternativa?

Para aquellos que están buscando en Google esto y terminaron aquí como yo, así es como lo haces actualmente en EF5 y EF6:

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

Suponiendo que el contexto es un System.Data.Entity.DbContext

Advertencia: lo siguiente solo es adecuado para tablas pequeñas (piense <1000 filas)

Aquí hay una solución que usa el marco de entidad (no SQL) para eliminar las filas, por lo que no es específico del motor SQL (R / DBM).

Esto supone que está haciendo esto para probar o alguna situación similar. Ya sea

• La cantidad de datos es pequeña o
• El rendimiento no importa

Simplemente llame:

VotingContext.Votes.RemoveRange(VotingContext.Votes);

Suponiendo este contexto:

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

Para el código más ordenado, puede declarar el siguiente método de extensión:

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

Entonces lo anterior se convierte en:

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

Recientemente utilicé este enfoque para limpiar mi base de datos de prueba para cada ejecución de caso de prueba (obviamente es más rápido que recrear la base de datos desde cero cada vez, aunque no verifiqué la forma de los comandos de eliminación que se generaron).

¿Por qué puede ser lento?

1. EF obtendrá TODAS las filas (VotingContext.Votes)
2. y luego usarán sus ID (no estoy seguro exactamente cómo, no importa), para eliminarlos.

Entonces, si está trabajando con una gran cantidad de datos, matará el proceso del servidor SQL (consumirá toda la memoria) y lo mismo para el proceso IIS, ya que EF almacenará en caché todos los datos de la misma manera que el servidor SQL. No use este si su tabla contiene una gran cantidad de datos.

Usar el TRUNCATE TABLEcomando de SQL será el más rápido ya que opera en la tabla y no en filas individuales.

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

Suponiendo que dataDbes un DbContext(no un ObjectContext), puede envolverlo y usar el método de esta manera:

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

Puedes hacerlo sin Foreach

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

Esto eliminará todas las filas

Esto evita usar cualquier sql

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

Me encontré con esta pregunta cuando tuve que lidiar con un caso particular: la actualización completa del contenido en una tabla de "hojas" (sin que los FK lo señalaran). Esto implicó la eliminación de todas las filas y la colocación de información de filas nuevas y debe hacerse transaccionalmente (no quiero terminar con una tabla vacía, si las inserciones fallan por alguna razón).

He intentado el public static void Clear<T>(this DbSet<T> dbSet)enfoque, pero no se insertan nuevas filas. Otra desventaja es que todo el proceso es lento, ya que las filas se eliminan una por una.

Entonces, cambié a TRUNCATEenfoque, ya que es mucho más rápido y también es ROLLBACKable . También restablece la identidad.

Ejemplo usando patrón de repositorio:

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

Por supuesto, como ya se mencionó, esta solución no puede ser utilizada por tablas referenciadas por claves foráneas (falla TRUNCATE).

Si

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

causas

No se puede truncar la tabla 'MyTable' porque está siendo referenciada por una restricción FOREIGN KEY.

Yo uso esto :

      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 desea borrar toda su base de datos.

Debido a las restricciones de clave externa, importa qué secuencia se truncan las tablas. Esta es una forma de aplicar fuerza bruta a esta secuencia.

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

uso:

ClearDatabase<ApplicationDbContext>();

recuerde reinstalar su DbContext después de esto.

Lo siguiente funciona en la base de datos SQLite (usando Entity Framework)

Parece que la forma más rápida de borrar todas las tablas de db es usando 'context.Database.ExecuteSqlCommand ("some SQL")', como también se resaltaron algunos comentarios anteriores. Aquí voy a mostrar cómo restablecer el recuento de 'índice' de tablas también.

            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 es que si usa claves foráneas en sus tablas, primero debe eliminar la tabla secundaria antes que la tabla primaria, por lo que la secuencia (jerarquía) de las tablas durante la eliminación es importante, de lo contrario puede ocurrir una excepción SQLite.

Nota: var context = new YourContext ()

Esto funciona correctamente en EF 5:

YourEntityModel myEntities = new YourEntityModel();

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

En EFCore (la versión que estoy usando es la 3.1) puede usar lo siguiente para eliminar todas las filas:

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

Eliminar todos los registros. No restablezca el índice primario como "truncar".

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

En mi código, realmente no tenía un buen acceso al objeto de la base de datos, por lo que puede hacerlo en el DbSet donde también se le permite usar cualquier tipo de sql. De alguna manera terminará así:

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

Si MVC, puedes hacer:

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

Asegúrese de que cuando intente eliminar el elemento primario, todos los elementos secundarios se eliminarán en cascada. O los niños tienen clave foránea anulable.

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