modo più efficiente la gestione Create, Update, Delete con il codice Entity Framework Prima

Question

Nota: Sto usando la versione di Entity Framework 5

Dentro il mio repository generico, ho Add, Edit e Delete metodi, come di seguito :

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

Pensi che questi metodi siano ben implementati? Soprattutto il metodo Add. Sarebbe meglio implementare il metodo Add come di seguito?

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

Per aggiungere:

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

Per l'aggiornamento:

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

Per cancellazione:

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

E un metodo privato Save() che restituisce vero o falso in modo da poter fallback facile nel controller a seconda del risultato

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

questa è solo una parte del mio repository generico. Funziona alla grande nelle applicazioni aziendali.

UPDATE:

Detach influenza solo l'oggetto specifico passato al metodo. Se l'oggetto scollegato ha oggetti correlati nel contesto dell'oggetto, tali oggetti non vengono scollegati.

EF allegherà automaticamente oggetti distaccati nel grafico quando si imposta lo stato di un'entità o quando viene chiamato SaveChanges().

Non so davvero perché è necessario staccare gli oggetti dal contesto. È inoltre possibile utilizzare AsNoTracking() per caricare entità dal database senza collegarle al contesto in primo luogo.