Código de Entity Framework Primero eliminar por ID sin recuperar (estilo genérico)

Question

Por favor dígame si este es un enfoque decente para eliminar una entidad sin recuperarlo dado que tengo la identificación.

que tienen una tienda genérico con la siguiente interfaz (yo sólo voy a mostrar Eliminar):

public interface IStore : IReadOnlyStore 
{ 
    void Delete<TEntity>(TEntity entity) where TEntity : class, IEntity, new(); 
    void SaveChanges(); 
} 

Y en la clase tienda concreta de esa interfaz, aquí está mi método de eliminación:

public void Delete<TEntity>(TEntity entity) where TEntity : class, IEntity, new() 
{ 
    var obj = Ctx.Entry(entity); 
    if (obj.State == System.Data.EntityState.Detached) 
    { 
     Ctx.Set(typeof(TEntity)).Attach(obj.Entity); 
    } 
    Ctx.Set(typeof(TEntity)).Remove(obj.Entity); 
} 

he probado tanto Newing hasta una entidad:

Store.Delete(new Foo() { Id = request.Entity.Id }); 

, así como ir a buscar una entidad y luego callos ng eliminar.

A través de la depuración, tengo el efecto deseado en ambos escenarios.

Solo quiero asegurarme de que este sea un buen diseño y que no haya efectos secundarios en este enfoque.

Como referencia, Ctx es solo el propio DbContext.

Gracias.

Answer 1

Es un buen diseño y no tiene efectos secundarios :) (en mi humilde opinión)

dos observaciones:

• Me pregunto si se puede simplificar su método Delete por:

  public void Delete<TEntity>(TEntity entity) 
      where TEntity : class, IEntity, new() 
  { 
      Ctx.Entry(entity).State = EntityState.Deleted; 
  } 
  

  Espero que establecer el estado en Deleted se adjuntará automáticamente si la entidad no está conectada. Pero no estoy seguro de si funciona. (Avíseme si funciona para escenarios adjuntos y separados (si debe probar esto).

• Si tiene en cuenta la optimización del rendimiento (evitando cargar las entidades), no olvide que, si hay múltiples entidades a eliminar en el contexto, SaveChanges aún enviará una única declaración DELETE por entidad a la base de datos. Las eliminaciones masivas con EF son bastante terribles en rendimiento y es un terreno donde volver a las sentencias de SQL (BORRAR ... DONDE ... EN ... muchos ID ...) a veces tiene sentido (si el rendimiento importa).