Rozwiązanie błędu "EF tracking entity with same ID"

 foreach (var type in types)
{
    var trackedEntities = applicationDbContext.Set<TypeEntity>().Local.Where(x => x.Id == type.Id).ToArray();
    if (trackedEntities != null && trackedEntities.Any())
    {
        foreach(var e in trackedEntities)
        applicationDbContext.Entry(e).State = EntityState.Detached;
    }
}

public static void ConfigureBackgroundTasksDI(this IServiceCollection services)
{
    services.AddHostedService<ConsumeScopedServiceHostedService>();
    services.AddScoped<IScopedProcessingService, ScopedProcessingService>();
    services.AddScoped<ISynchronizationBackgroundService, SynchronizationBackgroundService>();
    services.AddScoped<ISyncAllBackgroundService, SyncAllBackgroundService>();
    services.AddScoped<IMissionSynchronizationService, MissionSynchronizationBackgroundService>();
    services.AddScoped<IMessageTypeSynchronizationService, MessageTypesSynchronizationService>();
    services.AddScoped<IMissionsChecklistSynchronizationService, MissionsChecklistSynchronization>();
    services.AddSingleton<IEntitiesUpdatesNotifier, EntitiesUpdatesNotifier>();
}

  public class ConsumeScopedServiceHostedService : BackgroundService
{
    public IServiceProvider Services { get; }
    public ConsumeScopedServiceHostedService(IServiceProvider services)
    {
        Services = services;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        using (var scope = Services.CreateScope())
        {
            var scopedProcessingService =
                scope.ServiceProvider
                    .GetRequiredService<IScopedProcessingService>();

            await scopedProcessingService.DoWork(stoppingToken);
        }
    }
}

public interface IScopedProcessingService
{
    Task DoWork(CancellationToken stoppingToken);
}

public class ScopedProcessingService : IScopedProcessingService
{
    private readonly ISyncAllBackgroundService _syncAllService;
    private readonly IMissionSynchronizationService _missionSyncService;
    private readonly IMessageTypeSynchronizationService _messageTypeSynchronizationService;
    private readonly IMissionsChecklistSynchronizationService _missionsChecklistSynchronizationService;
    private readonly IConfiguration _configuration;

    public ScopedProcessingService(ISyncAllBackgroundService syncService,
        IConfiguration configuration,
        IMissionSynchronizationService missionSyncService,
        IMessageTypeSynchronizationService messageTypeSynchronizationService,
        IMissionsChecklistSynchronizationService missionsChecklistSynchronizationService)
    {
        _syncAllService = syncService;
        _configuration = configuration;
        _missionSyncService = missionSyncService;
        _messageTypeSynchronizationService = messageTypeSynchronizationService;
        _missionsChecklistSynchronizationService = missionsChecklistSynchronizationService;
    }

    public async Task DoWork(CancellationToken stoppingToken)
    {
        var tasks = new[]
        {
            Sync(stoppingToken, _syncAllService.Synchronize, GetLoopSyncAllIntervalInMiliseconds),
            Sync(stoppingToken,  _missionSyncService.Synchronize , GetLoopSyncCreatedEntitiesInMiliseconds),
            Sync(stoppingToken, _messageTypeSynchronizationService.Synchronize, GetLoopSyncCreatedEntitiesInMiliseconds),
            Sync(stoppingToken, _missionsChecklistSynchronizationService.Synchronize, GetLoopSyncCreatedEntitiesInMiliseconds)
        };
      
        await Task.WhenAll(tasks);
    }


 
    private async Task Sync(CancellationToken stoppingToken,Func<Task> task, Func<int> getIntervalMiliseconds)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            var ms = getIntervalMiliseconds();
            if (ms > 0)
            {
                try
                {
                    await task();
                }
                catch (Exception ex)
                {
                    Log.Error($"SYNCHRONIZATION ERROR {ex.Message} {ex.InnerException?.Message}");
                }
            }
            Thread.Sleep(ms);
        }
    }

protected virtual void AddDbContext(IServiceCollection services)
{
    string connectionString = GetConnectionString();
    services.AddDbContext<ApplicationDbContext>(item => item.UseSqlServer(connectionString,
      sqlServerOptions => sqlServerOptions.CommandTimeout(300)), contextLifetime: ServiceLifetime.Transient);
}

using (var scope = Services.CreateScope())
{
    var scopedProcessingService =
        scope.ServiceProvider
            .GetRequiredService<IScopedProcessingService>();

    await scopedProcessingService.DoWork(stoppingToken);
}