manejo más eficiente crear, actualizar, eliminar con el Código Marco de la entidad Primera

Question

Nota: estoy usando Entity Framework versión 5

Dentro de mi repositorio genérico, tengo Add, Edit y Delete métodos como abajo :

public class EntityRepository<T> : IEntityRepository<T> 
    where T : class, IEntity, new() { 

    readonly DbContext _entitiesContext; 

    public EntityRepository(DbContext entitiesContext) { 

     if (entitiesContext == null) { 

      throw new ArgumentNullException("entitiesContext"); 
     } 

     _entitiesContext = entitiesContext; 
    } 

    //... 

    public virtual void Add(T entity) { 

     DbEntityEntry dbEntityEntry = _entitiesContext.Entry<T>(entity); 
     if (dbEntityEntry.State != EntityState.Detached) { 

      dbEntityEntry.State = EntityState.Added; 
     } 
     else { 

      _entitiesContext.Set<T>().Add(entity); 
     } 
    } 

    public virtual void Edit(T entity) { 

     DbEntityEntry dbEntityEntry = _entitiesContext.Entry<T>(entity); 
     if (dbEntityEntry.State == EntityState.Detached) { 

      _entitiesContext.Set<T>().Attach(entity); 
     } 

     dbEntityEntry.State = EntityState.Modified; 
    } 

    public virtual void Delete(T entity) { 

     DbEntityEntry dbEntityEntry = _entitiesContext.Entry<T>(entity); 
     if (dbEntityEntry.State != EntityState.Detached) { 

      dbEntityEntry.State = EntityState.Deleted; 
     } 
     else { 

      DbSet dbSet = _entitiesContext.Set<T>(); 
      dbSet.Attach(entity); 
      dbSet.Remove(entity); 
     } 
    } 
} 

¿Cree que estos métodos están bien implementados? Especialmente el método Add. ¿Sería mejor implementar el método Add como a continuación?

public virtual void Add(T entity) { 

    DbEntityEntry dbEntityEntry = _entitiesContext.Entry<T>(entity); 
    if (dbEntityEntry.State == EntityState.Detached) { 

     _entitiesContext.Set<T>().Attach(entity); 
    } 

    dbEntityEntry.State = EntityState.Added; 
} 

Answer 1

Para añadir:

public bool Add<E>(E entity) where E : class 
     { 
      DataContext.Entry(entity).State = System.Data.EntityState.Added; 
      Save(); 
     } 

Para la actualización:

public bool Update<E>(E entity) where E : class 
     { 
      DataContext.Entry(entity).State = System.Data.EntityState.Modified; 
      Save(); 
     } 

Para borrar:

public bool Delete<E>(E entity) where E : class 
     { 
      DataContext.Entry(entity).State = System.Data.EntityState.Deleted; 
      Save(); 
     } 

Y un Save() método privado que devuelve verdadero o falso para que pueda repliegue fácil en el controlador en función del resultado

private bool Save() 
     { 
      return DataContext.SaveChanges() > 0;     
     } 

Esta es sólo una parte de mi repositorio genérico. Funciona muy bien en aplicaciones empresariales.

UPDATE:

Detach sólo afecta al objeto específico pasado al método. Si el objeto que se está separando tiene objetos relacionados en el contexto del objeto, esos objetos no están separados.

EF adjuntará automáticamente objetos separados en el gráfico de la hora de establecer el estado de una entidad o cuando SaveChanges() se llama.

Realmente no sé por qué necesita separar objetos del contexto. También puede usar AsNoTracking() para cargar entidades de la base de datos sin asociarlas al contexto en primer lugar.