Cómo eliminar un objeto por id con el marco de la entidad

Me parece que tengo que recuperar un objeto antes de eliminarlo con el marco de la entidad como se muestra a continuación

var customer = context.Customers.First(c => c.Id == 1);

context.DeleteObject(customer);

context.Savechanges();

Entonces necesito ingresar a la base de datos dos veces. ¿Existe una forma más sencilla?

En Entity Framework 6, la acción de eliminación es Remove. Aquí hay un ejemplo

Customer customer = new Customer () { Id = id };
context.Customers.Attach(customer);
context.Customers.Remove(customer);
context.SaveChanges();

Lo mismo que @Nix con un pequeño cambio para ser fuertemente tipado:

Si no desea consultarlo, simplemente cree una entidad y luego elimínela.

                Customer customer = new Customer () { Id = id };
                context.Customers.Attach(customer);
                context.Customers.DeleteObject(customer);
                context.SaveChanges();

Pregunta similar aquí .

Con Entity Framework existe EntityFramework-Plus (biblioteca de extensiones).
Disponible en NuGet. Entonces puedes escribir algo como:

// DELETE all users which has been inactive for 2 years
ctx.Users.Where(x => x.LastLoginDate < DateTime.Now.AddYears(-2))
     .Delete();

También es útil para eliminaciones masivas.

Si no desea consultarlo, simplemente cree una entidad y luego elimínela.

Customer customer  = new Customer() {  Id = 1   } ; 
context.AttachTo("Customers", customer);
context.DeleteObject(customer);
context.Savechanges();

Estoy usando el siguiente código en uno de mis proyectos:

    using (var _context = new DBContext(new DbContextOptions<DBContext>()))
    {
        try
        {
            _context.MyItems.Remove(new MyItem() { MyItemId = id });
            await _context.SaveChangesAsync();
        }
        catch (Exception ex)
        {
            if (!_context.MyItems.Any(i => i.MyItemId == id))
            {
                return NotFound();
            }
            else
            {
                throw ex;
            }
        }
    }

De esta manera, consultará la base de datos dos veces solo si ocurre una excepción al intentar eliminar el elemento con el ID especificado. Luego, si no se encuentra el elemento, devuelve un mensaje significativo; de lo contrario, simplemente devuelve la excepción (puede manejar esto de una manera más adecuada a su caso usando diferentes bloques de captura para diferentes tipos de excepciones, agregue más verificaciones personalizadas usando bloques if, etc.).

[Estoy usando este código en un proyecto MVC .Net Core / .Net Core con Entity Framework Core.]

La consulta sql sin procesar es la forma más rápida, supongo

public void DeleteCustomer(int id)
{
   using (var context = new Context())
   {
      const string query = "DELETE FROM [dbo].[Customers] WHERE [id]={0}";
      var rows = context.Database.ExecuteSqlCommand(query,id);
      // rows >= 1 - count of deleted rows,
      // rows = 0 - nothing to delete.
   }
}

La respuesta de dwkd funcionó principalmente para mí en el núcleo de Entity Framework, excepto cuando vi esta excepción:

InvalidOperationException: la instancia del tipo de entidad 'Cliente' no se puede rastrear porque ya se está rastreando otra instancia con el mismo valor de clave para {'Id'}. Al adjuntar entidades existentes, asegúrese de que solo se adjunte una instancia de entidad con un valor clave determinado. Considere usar 'DbContextOptionsBuilder.EnableSensitiveDataLogging' para ver los valores clave en conflicto.

Para evitar la excepción, actualicé el código:

Customer customer = context.Customers.Local.First(c => c.Id == id);
if (customer == null) {
    customer = new Customer () { Id = id };
    context.Customers.Attach(customer);
}
context.Customers.Remove(customer);
context.SaveChanges();

Una versión más pequeña (en comparación con las anteriores):

var customer = context.Find(id);
context.Delete(customer);
context.SaveChanges();

Esta respuesta en realidad se tomó del curso de Scott Allen titulado ASP.NET MVC 5 Fundamentals. Pensé en compartirlo porque creo que es un poco más simple e intuitivo que cualquiera de las respuestas aquí. También tenga en cuenta que según Scott Allen y otros entrenamientos que he realizado, el método de búsqueda es una forma optimizada de recuperar un recurso de la base de datos que puede usar el almacenamiento en caché si ya se ha recuperado. En este código, colección se refiere a un DBSet de objetos. El objeto puede ser cualquier tipo de objeto genérico.

        var object = context.collection.Find(id);  
        context.collection.Remove(object);
        context.SaveChanges();