We Keep Coding

Entity Framework: Entity of type x cannot be tracked because another instance with same key is already being tracked

When I try to update a Tafel record, I receive an error. Restaurant has a navigational collection of Tafels. I'm not quite sure if I should add the restaurant as a parameter but a Tafel has a composite primary key and restaurantId is part of it (together with a tablenumber)... I'm quite new to EF..
I check for possible nulls at first, then if they both exist and whether the 'tafel' record has any changes to it.
public void UpdateTafel(Tafel tafel, Restaurant restaurant)
{
if (tafel == null) throw new RestaurantManagerException("UpdateTafel: Tafel mag niet null zijn");
if (restaurant == null) throw new RestaurantManagerException("UpdateTafel: Restaurant mag niet null zijn");
try
{
if (!_restaurantRepository.BestaatRestaurant(restaurant.Id)) throw new RestaurantManagerException("GeefAlleTafelsVanRestaurant - restaurant bestaat niet");
if (!_restaurantRepository.BestaatTafel(tafel.Tafelnummer, restaurant)) throw new RestaurantManagerException("GeefAlleTafelsVanRestaurant - tafel bestaat niet");
Tafel db = _restaurantRepository.GeefTafel(tafel.Tafelnummer, restaurant);
if (tafel.IsDezelfde(db)) throw new ReservatieManagerException("Niks gewijzigd");
_restaurantRepository.UpdateTafel(tafel, restaurant);
}
catch (Exception ex)
{
throw new ReservatieManagerException("UpdateTafel", ex);
}
}
However when he gets to the repository method where EF has to actually update the said Tafel record with following method:
public void UpdateTafel(Tafel tafel, Restaurant restaurant)
{
_context.Tafels.Update(tafel);
_context.SaveChanges();
}
I receive an exception stating that another instance of Restaurant with the same key is already being tracked allthough I don't see quite how/where this happens...
Inner Exception 1:
InvalidOperationException: The instance of entity type 'Restaurant' cannot be tracked because another instance with the key value '{Id: 1}' is already being tracked. When attaching existing entities, ensure that only one entity instance with a given key value is attached.
public void UpdateTafel(Tafel tafel, Restaurant restaurant)
{
_context.Entry(restaurant).State = EntityState.Detached;
_context.Tafels.Update(tafel);
_context.SaveChanges();
}

If the tafel is a result of .Find method, it is really already tracked. So, the .Update tries to start it's tracking for the second time and throws the error. https://learn.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.dbcontext.update

This error occurs when you start mixing different entity instances referencing the same data. This commonly happens when deserializing data into entities, or if your DbContext reference lifetime scope is set to Transient where different repositories etc. end up loading and tracking entities, then those individual instances start getting passed around.
The culprit in your case is probably this method:
if (!_restaurantRepository.BestaatRestaurant(restaurant.Id)) throw new RestaurantManagerException("GeefAlleTafelsVanRestaurant - restaurant bestaat niet");
"restaurant" as a reference to a instance of a restaurant record in the scope of the DbContext that the repository is using, isn't tracked. This class instance was either loaded by a different DbContext instance or constructed from data. My guess is that the above call is telling the Repository to Load a restaurant by ID and within the scope of that method will be something like:
var restaurant = _context.Restaurants.SingleOrDefault(r => r.Id == restaurantId);
followed maybe by some more logic, a check if restaurant is null, etc. before returning True or False.
The issue is that even if you don't do anything with or return that reference you've loaded, the DbContext instance that the repository is using is now tracking that entity for that restaurant.
So if you do something like make a new Tafel and assign it the restaurant reference from "outside" the scope, that instance the DbContext isn't tracking, then try to save that Tafel, you get the exception that the DbContext is already tracking an entity with the same ID. (The reference that was loaded by BestaatRestaurant and/or other calls that might have fetched an entity.)
The obvious fix might sound like using AsNoTracking() in calls that read data to avoid keeping tracking references, and this would prevent errors like this, however it's very easy to forget to do, leading to situational exceptions, and you will probably find that even without this exception you'd probably find that using Update on your Tafel with the untracked Restaurant reference would have some undesireable behaviour like throwing an exception about a duplicate unique constraint on the PK, or it would duplicate the Restaurant in the DB with a new ID.
Working with untracked / detached entities is tricky and honestly should be avoided. If your goal is to save a Tafel and associate it to an existing Restaurant, then AVOID passing entity references around and instead just pass the ID of the entity to associate. For instance:
public void UpdateTafel(TafelViewModel tafel, int restaurantId)
{
if (tafel == null) throw new RestaurantManagerException("UpdateTafel: Tafel mag niet null zijn");
try
{
var restaurant = _restaurantRepository.BestaatRestaurant(restaurantId); // Fetch the restaurant and return it after validating, Throw if not found/valid.
if (!_restaurantRepository.BestaatTafel(tafel.Tafelnummer))
throw new RestaurantManagerException("GeefAlleTafelsVanRestaurant - tafel bestaat niet");
Tafel existingTafel = _restaurantRepository.GeefTafel(tafel.Tafelnummer); // Ensure this eager loads Tafel.Restaurant
// If the Restaurant has changed then update the reference in our tracked entities.
if (existingTafel.Restaurant.Id != restaurant.Id)
existingTafel.Restaurant = restaurant;
// I'm assuming this is doing something like updating the database instance with the values in the passed in reference? If so you could pass the Restaurant instance above in and do that check/update here.
if (tafel.IsDezelfde(existingTafel)) throw new ReservatieManagerException("Niks gewijzigd");
_restaurantRepository.SaveChanges();
}
catch (Exception ex)
{
throw new ReservatieManagerException("UpdateTafel", ex);
}
}
The key differences I would outline. First, note that the model passed into this method is not a Tafel entity, but rather a view model. You can use an entity, but you should avoid confusing data that doesn't actually represent a tracked, whole entity with a proper entity. Methods that accept an entity shouldn't need to make assumptions or checks whether this is just data filled in or deserialized vs. a living breathing tracked entity reference. We also just pass the selected restaurant ID. The verification for the restaurant actually loads and returns a tracked Restaurant reference that we can associate. We also go to the repository to retrieve the tracked, live existing Tafel instance based on the ID of the view model passed in. From there we can copy values from the view model into the tracked entity, including associating a new tracked Restaurant reference if it's changed. From there since we are dealing with tracked entities, the only thing left to do is tell the DbContext (through the repository) to SaveChanges. There is no need to use Update. There should be only one tracked instance of each entity being within the scope of the DbContext. Update is used for untracked, detached entities.

EF Core duplicate keys: The instance of entity type '' cannot be tracked because another instance with the key value '' is already being tracked

I'm working on a form using EF Core in Blazor Server. I had a number of issues with entity tracking so I set all of my queries to AsNoTracking and designed my service to create a new instance of dbcontext for each query. I think this is appropriate as none of the returned values will be edited - only the form data that users enter and the id references to the queried fields, such as employee numbers, will be stored. For inserting data, I use this:
using var context = Factory.CreateDbContext();
context.SetupForm.Attach(model);
context.Entry(model).State = EntityState.Added;
await context.SaveChangesAsync();
I am attaching the data rather than adding it and then setting the form object state to added. This ensures EF Core doesn't attempt to insert the existing employee objects when it inserts the form data.
The trouble starts in a section of the form that can have as many items as the user wants. The select a couple of employees and type in relevant data. When they submit the form, they may have selected the same employee in multiple items. As these employees were selected from separate contexts, they are two separate instances with the same ID. Of course, EF Core doesn't like this and throws errors like this one:
The instance of entity type 'Principal' cannot be tracked because another instance with the key value '{EmployeeID: 1234}' is already being tracked. When attaching existing entities, ensure that only one entity instance with a given key value is attached.
I understand why this error is occurring but I need to be able to attach multiple entities in this way. How can I work around this issue?
One thing I could do is assign the foreign keys manually but that would be rigid and require updates whenever the model changes.

just try this
using var context = Factory.CreateDbContext();
context.Set<Principal>().Add(model);
//or maybe context.Principals.Add(model);
await context.SaveChangesAsync();

This seems to do the trick! What it does is mark any entity that lacks a key as added. Otherwise, the entity is ignored entirely.
using var context = Factory.CreateDbContext();
context.ChangeTracker.TrackGraph(model, node =>
{
if (!node.Entry.IsKeySet)
{
node.Entry.State = EntityState.Added;
}
});
await context.SaveChangesAsync();
None of the items that have a key will need to be inserted. Treating them as untracked then solves any issues with duplicates and only inserts the rows that need it.
More information: https://learn.microsoft.com/en-us/ef/core/change-tracking/identity-resolution#resolve-duplicates

Entity Framework Core 5: The different between saving use Add(oldItem) and db.Entry(oldItem).State = EntityState.Modified?

I am using Entity Framework Core 5.0.3, .NET 5.0.103, ASP.NET Core 5 Blazor WebAssebmly. I have -
// Cập nhật
[HttpPut("{id}")]
public async Task<ActionResult> UpdateItem(int id, ProjectWorkCategory newItem)
{
var oldItem = await db.ProjectWorkCategories.FindAsync(id);
if (oldItem == null)
{
return NotFound();
}
// Mã loại công trình.
if (!string.IsNullOrEmpty(newItem.ProjectWorkCategoryCode))
{
oldItem.ProjectWorkCategoryCode = newItem.ProjectWorkCategoryCode;
}
// Tên loại công trình
if (!string.IsNullOrEmpty(newItem.ProjectWorkCategoryName))
{
oldItem.ProjectWorkCategoryName = newItem.ProjectWorkCategoryName;
}
// Diễn giải
if (!string.IsNullOrEmpty(newItem.Description))
{
oldItem.Description = newItem.Description;
}
// Trạng thái theo dõi.
if (newItem.ActiveStatus != oldItem.ActiveStatus)
{
oldItem.ActiveStatus = newItem.ActiveStatus;
}
// Người sửa.
if (!string.IsNullOrEmpty(newItem.ModifiedBy))
{
oldItem.ModifiedBy = newItem.ModifiedBy;
}
oldItem.ModifiedDate = DateTime.Now;
//db.ProjectWorkCategories.Add(oldItem);
db.Entry(oldItem).State = EntityState.Modified;
await db.SaveChangesAsync();
return NoContent();
}
What is the different between
db.ProjectWorkCategories.Add(oldItem);
await db.SaveChangesAsync();
versus
db.Entry(oldItem).State = EntityState.Modified;
await db.SaveChangesAsync();

db.ProjectWorkCategories.Add(oldItem);
await db.SaveChangesAsync();
the above code adds the entity to database. if 'oldItem' has Unique Id, then you will get exception trying to save it, otherwise it would save duplicate record.
db.Entry(oldItem).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
await db.SaveChangesAsync();
this is the correct way to update an entity.

A record will be added to the database when you use the add method. But if you use the 'State = Microsoft.EntityFrameworkCore.EntityState.Modified', your existing record will be edited in the database.

This one is adding a new item, and as mentioned by #Navid it will through an error if it has a unique Id.
db.ProjectWorkCategories.Add(oldItem);
await db.SaveChangesAsync();
If you want to update you should be using Update method:
db.ProjectWorkCategories.Update(oldItem);
await db.SaveChangesAsync();
This one also can be used for updating an existing item.
db.Entry(oldItem).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
await db.SaveChangesAsync();
Deep dive:
Updated to explain the points mentioned by #atiyar comment
There is a some differences between using Add, Update methods and changing the entity state EntityState.Modified.
When using (1)Add Update method, the framework will start to track this entity as EntityState.Added if it has no Id assigned, or will track it as EntityState.Modified if it has an Id.
DbContext.Update Method:
For entity types with generated keys if an entity has its primary key value set then it will be tracked in the EntityState.Modified state. If the primary key value is not set then it will be tracked in the EntityState.Added state.
(2) When using Update method the framework will track the entity and all its referenced entities with EntityState.Modified flag.
(2) I still think this is valid. Please see the explanation in this document: Where this method differs from explicitly setting the State property, is in the fact that the context will begin tracking any related entities (such as a collection of books in this example) in the Modified state, resulting in UPDATE statements being generated for each of them. If the related entity doesn't have a key value assigned, it will be marked as Added, and an INSERT statement will be generated.
When using EntityState.Modified the framework will track this entity as EntityState.Modified. But all referenced entities will be tracked by EntityState.Unchanged flag, and you may need to change the state of each referenced entity to Modified manually.
Another difference, when calling SaveChanges() after Update method, only changed values of the entity will be submitted to the DB. But when you call SaveChanges() after using EntityState.Modified all values will be submitted to the DB since all fields has been marked as Modified.
(3) That is my mistake, I used to use another library which we can use to send only modified fields for update, but this is not valid for EF Update method.
EDIT
With reference to your update method, you can use both Update or EntityState.Modified. The easy way is to use Update(entity). In some advanced cases when the entity state could be Detached (un-tracked) I use EntityState flags to check if the entity is attached (tracked) or not, then I do modify its state accordingly.
Finally, instead of avoiding the result of SaveChangesAsync() I recommend to check the value and return:
var success = await db.SaveChangesAsync();
if(success > 0)
// log or message for success
else
// log or message for failure

Entity Framework tracks an entity with a State value, which you can check by -
var state = db.Entry(myEntity).State;
And when you call SaveChanges(), EF tries to insert, update or delete an entity based on its State value.
What Add() and EntityState.Modified do :
The Add() method marks an entity as Added (sets the State value to EntityState.Added), whether the entity has a primary key value or not, and when you call SaveChanges() the next time, EF will try to insert that entity.
db.Entry(myEntity).State = EntityState.Modified; sets the State value of the entity explicitly to Modified, which basically tells EF that "this entity already exits in database, and has been modified". Therefore, on the next SaveChanges() call EF will try to update the entity with its new values.
What Add() and EntityState.Modified will do in your scenario :
You are trying to update an entity not to insert it. For update operation you are not supposed to use the Add() method.
You fetched an existing entity from the database (and it has its primary key value in it) with -
var oldItem = await db.ProjectWorkCategories.FindAsync(id);
At this point the entity will be in Unchanged state. Then as soon as you set a new value to any of its properties, the entity gets modified and will automatically go in Modified state. But then if you call -
db.ProjectWorkCategories.Add(oldItem);
the Add() method will put the entity in Added state. At this point calling SaveChanges() will throw an exception, because EF is trying to insert an entity which already exists in database (the primary key violation).
In your scenario, by setting -
db.Entry(oldItem).State = EntityState.Modified;
you are explicitly marking the entity as Modified, and on the next SaveChanges() call EF will update the entity with its new values. But the thing is, you don't even need the above line. As I mentioned earlier, fetching an existing entity and changing any of its property value will automatically put the entity in Modified state. Therefore, after setting the new values you can directly call -
await db.SaveChangesAsync();
and your entity will get updated as expected.

Removing range using EF Core

I´m getting an error when using RemoveRange to bulk delete data, in my unit tests, using InMemoryDatabase.
Here is the code:
public void DeletePatient(Paciente patient)
{
var schedules = dbContext.Schedules.AsNoTracking().Where(x => x.PatientId == patient.Id).ToList();
dbContext.Schedules.RemoveRange(schedules);
dbContext.Patients.Remove(patient);
}
This throws this error:
InvalidOperationException: The instance of entity type 'Schedule' cannot be tracked because another instance of this type with the same key is already being tracked. When adding new entities, for most key types a unique temporary key value will be created if no key is set (i.e. if the key property is assigned the default value for its type). If you are explicitly setting key values for new entities, ensure they do not collide with existing entities or temporary values generated for other new entities. When attaching existing entities, ensure that only one entity instance with a given key value is attached to the context.
But, if I perform a foreach and reload each entity, it works:
foreach(var item in schedules)
{
var h = dbContext.Schedules.Find(item.Id);
dbContext.Remove(h);
}
The same foreach, using the item directly gives same error:
foreach(var item in schedules)
{
dbContext.Remove(item);
}

Try removing the AsNoTracking clause. I haven't tested it but my guess is this is causing EF to re-read the entities from the database and not finding the ones already in the context. Without the clause it should find the actual entities in the context to be removed.

Is this an EF Core bug or an I doing it wrong to update one entity?

I'm using Entity Framework Core together with the repository pattern. To help me out, I coded one base repository with the basic CRUD methods. The update method is as follows:
public void Update(TEntity entity)
{
var contextEntry = _context.Entry<TEntity>(entity);
if (contextEntry.State == EntityState.Dettached)
{
_context.Attach(entity);
}
contextEntry.State = EntityState.Modified;
_context.SaveChanges();
}
Given the BaseRepository class containing this method, I created one User repository inheriting from this
public class UserRepository : BaseRepository<User>, IUserRepository
{
}
And I've used this in the PUT method of one Web API coded with ASP.NET Core
[HttpPut("~/api/users/{id}")]
public IActionResult Put(int id, [FromBody] User user)
{
if (user == null || user.UserId != id)
{
return BadRequest();
}
userRepository.Update(user);
return new NoContentResult();
}
Now, when issuing a request, I get one error in the _context.Attach(entity) line. The exception says that it can't add the entity for tracking because there is already another entity with the same key being tracked.
When debugging I saw that contextEntry.State was set to Unchanged. Hence, it is obviously not equal to EntityState.Dettached. Still, the execution got inside the if statement and tried to attach the entity.
Something is quite wrong here. Is this a bug? Or am I doing something very wrong? I believe that I'm the one doing something very wrong with this update strategy, but I'm unsure about it. In that case, what is wrong with my approach?
EDIT: I updated the Update method to use just _context.Update(entity) and after _context.SaveChanges(). Still, the _context.Update(entity) throws one InvalidOperationException with this message:
Additional information: The instance of entity type 'User' cannot be tracked because another instance of this type with the same key is already being tracked. When adding new entities, for most key types a unique temporary key value will be created if no key is set (i.e. if the key property is assigned the default value for its type). If you are explicitly setting key values for new entities, ensure they do not collide with existing entities or temporary values generated for other new entities. When attaching existing entities, ensure that only one entity instance with a given key value is attached to the context.

You are getting same entity from database some where in the project that's why it give you error.
In Update method you just add the entity in the context that's why you get contextEntry.State Unchanged.
You can fix this problem in two ways.
You need to call the Detach method on same entity when you get it from database.
copy the values from entity which you received in Update method to the existing context entity and save that entity in database.

All the information is in the exception message... you already have another copy of the entity with that primary key attached.
I would recommend one of the following (preferred first):
Use a new Context for each action, don't have a long-lived repository/context
Use .Set<TEntity>.Find(object[] key) on your context using the Primary Key, in order to retrieve any entity you already have.
In your current update method, use the Set<TEntity>.Local.Find(..) to check if it already exists