EF Core Collections using Automapper.Collection.EntityFrameworkCore

Given I have 2 classes, Foo and Bar:

public class Foo
{
  private readonly List<Bar> _bars = new List<Bar>();

  public int Id { get; private set; }
  public string Name { get; private set; }
  public IEnumerable<Bar> Bars => _bars;

  public void AddBar(Bar bar)
  {
    _bars.Add(bar);
  }

  public static Foo Create(string name)
  {
    return new Foo { Name = name };
  }

  private Foo() { }
}

public class Bar
{
  public int Id { get; private set; }
  public string Description { get; private set; }

  public static Bar Create(string description)
  {
    return new Bar { Description = description };
  }
}

With 2 corresponding DTOs,

public class BarDto
{
  public int Id { get; set; }
  public string Description { get; set; }
}

public class FooDto
{
  public int Id { get; set; }
  public string Name { get; set; }
  public List<BarDto> Bars { get; set; }

  public FooDto()
  {
    Bars = new List<BarDto>();
  }
}

And an AutoMapper/AutoMapper.Collection.EntityFrameworkCore setup of

var config = new MapperConfiguration(cfg =>
{
    cfg.AddCollectionMappers();
    cfg.UseEntityFrameworkCoreModel<DemoContext>();
    cfg.CreateMap<BarDto, Bar>().EqualityComparison((src, dest) => src.Id == dest.Id);
    cfg.CreateMap<FooDto, Foo>().ForMember(dest => dest.Bars, opt =>
    {
      opt.MapFrom(s => s.Bars);
      opt.UseDestinationValue();
    }).EqualityComparison((src, dest) => src.Id == dest.Id);
});

I have a use case whereby the incoming FooDto may contain inserted, appended, updated and deleted items in the Bars collection which I am attempting to handle by:

1. Looking up the existing entity from the database
2. Mapping changes from the DTO to the entity
3. Saving the changes to the database

However the following code produces an InvalidOperationException exception stating that "The instance of entity type 'Bar' 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"

var fooToUpdate = db.Foos.Include(_ => _.Bars).FirstOrDefault(_ => _.Id == fooDto.Id);
mapper.Map(fooDto, fooToUpdate);
db.SaveChanges();

My understanding was that becuase I am setting EqualityComparison for the BarDto -> Bar mapping it should update the tracked entity and the save operation should succeed becuase it was referencing the same object?

I am not sure if I'm going about this the wrong way or simply missing somthing in the configuration.

Update

It seems the problem I am facing may be related to this issue on github.