Why do I get tracking error while updating entity in EF Core?

Question

I have a model class Patient:

    [Key]
    [Required(ErrorMessage = "")]
    [MinLength(3)]
    public string PatientCode { get; set; }

    [Required(ErrorMessage = "")]
    [MinLength(1)]
    public string Name { get; set; }

    [Required(ErrorMessage = "")]
    [MinLength(1)]
    public string Surname { get; set; }

I have a generic repository where I try to update my entity:

    public async Task<bool> UpdateAsync(T entity)
    {
        try
        {
            _applicationContext.Set<T>().Update(entity);
            await _applicationContext.SaveChangesAsync();

            return true;
        }
        catch (Exception)
        {
            return false;
        }
    }

which I call from my controller:

    private readonly IRepository<Patient> _patientRepository;
    ...
    [HttpPatch("update/")]
    public async Task<IActionResult> UpdateAsync([FromBody] Patient patient)
    {
        var result = await _patientRepository.UpdateAsync(patient);
    
        if (result)
            return Ok();
    
        return BadRequest();
    }

And when I do so, I get this error:

The instance of entity type 'Patient' cannot be tracked because another instance with the same key value for {'PatientCode'} is already being tracked

If I comment out setting the entity in my repository (comment line _applicationContext.Set<T>().Update(entity);) everything works just fine. It means that my entity has been attached to the ChangeTracker somehow. But how is it possible in such a straight forward code?

Answer 1

The error occurs when a DbContext instance is given an entity reference that it isn't tracking that has a same key value with an entity reference that it is tracking. This can be a common problem in application designs that use Dependency Injection for the DbContext since within the scope of a single repository that gets an injected DbContext it's an unknown what entity references that DbContext might already be tracking. For instance if your code happens to load a different entity that happens to have a reference to that particular Patient record that is either eager or lazy loaded, then passing a different entity reference, such as one that has been deserialized/mapped from a POST payload and calling Update will result in this exception, and it can be situational depending on whether the DbContext happens to be tracking that matching entity or not.

Passing entities around beyond the scope of their DbContext including serialization/deserialization requires extra care when dealing with updating entities and references to related entities. It also means you need to be prepared to deal with tracked references.

Since different entities will likely use different keys, I strongly recommend moving away from the Generic Repository pattern, or at least mitigate it to truly identical lowest-common-denominator type base code. Too many developers end up painting themselves into a tight corner far from the doorway with this anti-pattern.

public async Task<bool> UpdateAsync(Patient patient)
{
    try
    {   // Going to .Local checks for tracked references, it won't hit the DB.
        var trackedReference = _applicationContext.Patients.Local
            .SingleOrDefault(p => p.PatientCode == patient.PatientCode);

        if (trackedReference == null)
        { // We aren't already tracking an entity so we should be safe to attempt an Update.
            _applicationContext.Patients.Update(patient);
        }
        else if (!Object.ReferenceEquals(trackedReference, patient))
        { // Here we have a bit more work to do. The DbContext is already 
          // tracking a reference to this Patient and it's *not* the copy
          // you are passing in... Need to determine what to do, copy
          // values across, etc.
            Mapper.Map(patient, trackedReference); // This would use Automapper to copy values into the tracked reference, overwriting.
        }

        // If the patient passed in is the same reference as the tracked
        // instance, nothing to do, just call SaveChanges.
        
        await _applicationContext.SaveChangesAsync();

        return true;
    }
    catch (Exception)
    {
        return false;
    }
}

This may look simple enough, but you need to apply these checks to all entities in the entity graph. So for instance if a Patient references other entities like Address etc. you need to check the DbContext to see if it is already tracking a reference (where that address might be updated or inserted). For references to existing data rows you will want to check and replace references with existing tracked references, or Attach them if not tracked to avoid EF attempting to treat the untracked reference as a new entity and try inserting it.