Additional information: The instance of entity type ... cannot be tracked because another instance of this type with the same key is already being tracked. For new entities consider using an IIdentityGenerator to generate unique key values.

I have a generic repository implemented in a class library all CRUD methods except works _dbSet.Remove(entity);

The instance of the object is defined as AddScope.

Could someone help me

An exception of type ‘System.InvalidOperationException’ occurred in EntityFramework.Core.dll but was not handled in user code

Additional information: The instance of entity type ‘TMS.Domain.Entities.Pais’ cannot be tracked because another instance of this type with the same key is already being tracked. For new entities consider using an IIdentityGenerator to generate unique key values.

public class RepositoryBase<TEntity> : IRepositoryBase<TEntity> where TEntity : class
{

    private IAppDbContext _dbContext;
    protected DbSet<TEntity> _dbSet;


    public RepositoryBase(IAppDbContext dbContext)
    {
        _dbContext = dbContext;
        _dbSet = _dbContext.Set<TEntity>();
    }

    //public RepositoryBase()
    //{
    //    _dbContext = new AppDbContext();
    //    _dbSet = _dbContext.Set<TEntity>();
    //}

    public virtual IEnumerable<TEntity> GetAll()
    {
        return _dbSet.ToList();
    }

    public IEnumerable<TEntity> GetAllAsReadOnly()
    {
        return _dbSet.AsNoTracking();
    }

    public virtual IEnumerable<TEntity> GetBy(Expression<Func<TEntity, bool>> filter)
    {
        return _dbSet.Where(filter);
    }

    public IQueryable<TEntity> GetQueryBy(Expression<Func<TEntity, bool>> filter)
    {
        return _dbSet.Where(filter);
    }

    public virtual void Create(TEntity entity)
    {
        _dbSet.Add(entity);
    }

    public virtual void Edit(TEntity entity)
    {
        _dbSet.Update(entity);
    }

    public virtual void Delete(TEntity entity)
    {
        _dbSet.Remove(entity);
    }

    public int Save()
    {
        return _dbContext.SaveChanges();
    }

    public void Dispose()
    {
        //_dbContext.Dispose();
        GC.SuppressFinalize(this);
    }

    public TEntity FindBy(Expression<Func<TEntity, bool>> filter)
    {
        return _dbSet.Where(filter).SingleOrDefault();
    }

    public TEntity FindAsReadOnlyBy(Expression<Func<TEntity, bool>> filter)
    {
        return _dbSet.Where(filter).AsNoTracking().SingleOrDefault();
    }

    public void Delete(Expression<Func<TEntity, bool>> filter)
    {
        TEntity entity = _dbSet.Where(filter).SingleOrDefault();
        _dbSet.Remove(entity);
    }
}

[gilmaremn]

It worked perfect with AsNoTracking ();

Thank you!

[rowanmiller]

Hey,

Looking at your code, I think it’s these lines of code in PaisesController.cs that are causing your issue…

141                 PaisViewModel paisViewModel = _paisApp.GetBy(id).SingleOrDefault(); 
142 
143                 ValidationResultApp result = _paisApp.DeleteValidation(paisViewModel); 

The “query for an instance and then mark as deleted” pattern you are doing is good, the problem is that because of the various layers of abstraction you don’t end up marking the actual entity instance as deleted, you attempt to tell the context that a new instance of the entity is deleted… but it has the same primary key value that was created when you queried for the entity from the database.

There are two options here:

• Update the repository to lookup the existing entity (based on the key values of the entity passed to the Delete method) and mark it as deleted.
• Use the AsNoTracking() method whenever you retrieve data, this avoids having the entities be tracked by the context and frees you up to re-attach new instances when you want to update/delete.