Local variable in async method holding EF loaded data is not garbage collected

[Cerberus4444]

I have noticed a behavior that I didn't quite expect.
When I load data asynchronously from a DbContext using EF and store it into a local variable, the memory will not get garbage collected after the method completed execution.

I have made a very small sample method to verify the behavior:

    public async Task RetrieveConfigurationFiles()
    {
        await using MandantDbContext mandantDbContext = new(
            new DbContextOptionsBuilder<MandantDbContext>()
                .UseSqlServer(%CONNECTIONSTRING%)
                .Options);

        DbSet<ConfigurationFile> dbSet = mandantDbContext.Set<ConfigurationFile>();

        List<ConfigurationFile> configurationFiles = await dbSet
            .AsNoTracking()
            .ToListAsync(CancellationToken.None);

        // Try clearing the reference to help GC
        configurationFiles = null;

        // Force GC
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
    }

DotMemory shows that the space on Heap generation 2 does not get freed up even after nullification of the variable and forced gc:

When I check the retention, DotMemory shows that most of these objects seem to be held by the async state machine.

Now the really weird part:
Even minutes after the method completed, when I force gc with DotMemory, the memory cannot be freed up.
It will keep around 600 MB in Heap generation 2.

When I run the method multiple times, "Heap generation 2" grows to around 1 GB before the added pressure on the memory seems to force a cleanup, bringing it down to around 600 MB again.
600 MB that again seems to be immune to forced gc.

This problem with the memory not being freed up by forced gc seems to be specific to this EF data loading.
A rather simple asynchronous memory allocation like this does not have the same problem:
byte[] configurationFiles = await Task.FromResult(new byte[1000000000000]);

Is there a specific memory retention behavior for data loaded with EF with async/await?

Thanks for your help.

[hez2010]

In your code mandantDbContext won't be disposed until the method returns, what if you change the code to

    public async Task RetrieveConfigurationFiles()
    {
        await using (MandantDbContext mandantDbContext = new(
            new DbContextOptionsBuilder<MandantDbContext>()
                .UseSqlServer(%CONNECTIONSTRING%)
                .Options))
        {

            DbSet<ConfigurationFile> dbSet = mandantDbContext.Set<ConfigurationFile>();

            List<ConfigurationFile> configurationFiles = await dbSet
                .AsNoTracking()
                .ToListAsync(CancellationToken.None);

            // Try clearing the reference to help GC
            configurationFiles = null;
        }
        // Force GC
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
    }

[Cerberus4444]

Thanks for your reply.
I've tried it with your code and the smaller using block of the DbContext.
Unfortunately, the behavior stays the same.

[CyberAndrii]

Not sure if this is always correct, but from my experience local variables won't get garbage collected if the method hasn't returned yet. You need to move GC.Collect() calls out of the RetrieveConfigurationFiles method.

[Cerberus4444]

Thanks for your reply.
I've tried refactoring the code according to your description:

    public async Task RetrieveConfigurationFiles()
    {
        await RetrieveConfigurationFilesInternal();

        // Force GC
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
    }

    private static async Task RetrieveConfigurationFilesInternal()
    {
        await using MandantDbContext mandantDbContext = new(
            new DbContextOptionsBuilder<MandantDbContext>()
                .UseSqlServer(%CONNECTIONSTRING%)
                .Options);

        DbSet<ConfigurationFile> dbSet = mandantDbContext.Set<ConfigurationFile>();

        List<ConfigurationFile> configurationFiles = await dbSet
            .AsNoTracking()
            .ToListAsync(CancellationToken.None);

        // Try clearing the reference to help GC
        configurationFiles = null;
    }

The Problem persists with GC placed outside of the EF executing method.
I have also tried force GC via DotMemory, which was also run after the method completion, and the memory was not freed up.