Gestion plus efficace de la création, de la mise à jour et de la suppression avec Entity Framework Code First

Question

Remarque: j'utilise Entity Framework version 5

Dans mon référentiel générique, j'ai les méthodes Add , Edit et Delete comme ci-dessous:

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

Pensez-vous que ces méthodes sont bien mises en œuvre? Surtout la méthode Add . Serait-il préférable de mettre en œuvre la méthode Add comme ci-dessous?

 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

Pour ajouter:

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

Pour mettre à jour:

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

Pour les supprimer:

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

Et un privé Save() méthode qui retourne vrai ou faux de sorte que vous pouvez de secours facile dans le contrôleur en fonction du résultat

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

Ce n'est qu'une partie de mon générique référentiel. Il fonctionne très bien dans les applications d'entreprise.

Mise à JOUR:

Détacher affecte uniquement l'objet spécifique passés à la méthode. Si l' objet détaché des objets dans le contexte de l'objet, ces les objets ne sont pas détachés.

EF seront automatiquement associer des objets détachés dans le graphique lors de la définition de l'état d'une entité ou lorsqu' SaveChanges() est appelé.

Je ne sais vraiment pas pourquoi vous avez besoin de détacher les objets du contexte. Vous pouvez également utiliser AsNoTracking() à la charge des entités de la base de données sans les attacher au contexte, en premier lieu.