Most efficiently handling Create, Update, Delete with Entity Framework Code First

Question

Note: I am using Entity Framework version 5

Inside my generic repository, I have Add, Edit and Delete methods as below:

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

Do you think whether these methods are well implemented? Especially the Add method. Would it be better to implement the Add method as below?

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

For add:

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

For update:

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

For delete:

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

And a private Save() method that returns true or false so you can fallback easy in the controller depending on the result

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

This is only a portion of my generic repository. It works great in enterprise applications.

UPDATE:

Detach only affects the specific object passed to the method. If the object being detached has related objects in the object context, those objects are not detached.

EF will automatically attach detached objects in the graph when setting the state of an entity or when SaveChanges() is called.

I really don't know why you need to detach objects from the context. You can also use AsNoTracking() to load entities from the database without attaching them to the context in the first place.