Suspect memory leak related to RichTextBox on .Net 10.0.102

[carltonshen-work]

.NET version

10.0.102

Did it work in .NET Framework?

Not tested/verified

Did it work in any of the earlier releases of .NET Core or .NET 5+?

Same code has no issue with .Net 8.0.

Issue description

I have a simple WinForm application which redirects console input/output and uses a RichTextBox for colored output.

When the program is compiled with .Net 10, it will accumulate about 10MB of memory usage every hour. Below is the GC Dump I've captured:

net10.202601161100.zip

And below is the PerfView top items for the Heap Stack view:

Name	Exc %	Exc	Exc Ct	Inc %	Inc	Inc Ct	Fold	Fold Ct
LIB <<System.Private.CoreLib!List<Runtime.InteropServices.ComWrappers+ManagedObjectWrapperHolder>>>	97.7	33,555,208	14	97.7	33,555,208	14	33,554,984	7
LIB <<System.Private.CoreLib!Diagnostics.Tracing.NativeRuntimeEventSource>>	0.6	199,730	2,457	0.6	199,730	2,457	198,886	2,443
LIB <<System.Diagnostics.Process!Diagnostics.Process>>	0.3	113,488	74	0.3	113,488	74	109,136	14
LIB <<System.Diagnostics.DiagnosticSource!Diagnostics.Metrics.MetricsEventSource>>	0.2	61,242	537	0.2	61,242	537	58,846	499
[local vars]	0.2	60,104	139	0.3	91,345	637	60,104	138
(more lines ignored)

However, if it is compiled with .Net 8.0, its memory usage is stable over time.

Steps to reproduce

Below is the procedure that is being repetitively called to add text to the RTB:

    private void AppendLineToConsoleWithColor(string text, Color color)
    {
        if (consoleOutput.InvokeRequired)
        {
            consoleOutput.Invoke(AppendLineToConsoleWithColor, text, color);
            return;
        }

        consoleOutput.SelectionStart = consoleOutput.TextLength;
        consoleOutput.SelectionLength = 0;
        consoleOutput.SelectionColor = color;

        consoleOutput.AppendText(text);
        consoleOutput.AppendText(Environment.NewLine);
        currentConsoleCharCount += text.Length;
        currentConsoleCharCount += Environment.NewLine.Length;

        consoleOutput.SelectionColor = consoleOutput.ForeColor;

        if (currentConsoleCharCount > loadedConfig.Settings.MaxConsoleChars)
        {
            int removeUpTo = consoleOutput.Text.IndexOf('\n', loadedConfig.Settings.TrimChunkSize);
            if (removeUpTo > 0)
            {
                Win32WindowAPI.SuspendRedraw(consoleOutput.Handle);
                try
                {
                    consoleOutput.Select(0, removeUpTo + 1);
                    consoleOutput.ReadOnly = false;
                    consoleOutput.SelectedText = string.Empty;
                    consoleOutput.ReadOnly = true;
                    consoleOutput.ClearUndo();
                }
                finally
                {
                    Win32WindowAPI.ResumeRedraw(consoleOutput.Handle);
                }
                currentConsoleCharCount = consoleOutput.TextLength;
            }
        }
    }

I believe anything that add text to RTB would trigger the same issue. I can already confirm the Win32 API call on the SuspendRedraw and ResumeRedraw is irrelevant, that remove them does not make any difference.

I have a test app that generates text continuously so the above code is called frequently, which I believe anything to the same effect will work.

[ricardobossan]

@carltonshen-work

Thank you for reporting this issue.

We attempted to reproduce the memory leak based on the code snippet you provided, but were unable to observe the behavior you described.

Our reproduction steps:

1. Created a WinForms application targeting net10.0-windows
2. Implemented the AppendLineToConsoleWithColor method as shown in your snippet
3. Set up a timer to call this method repeatedly (every 50ms)
4. Ran the application for 3 hours, taking GC dumps at intervals using dotnet-gcdump

Our results:

Snapshot 1 (1 min):   405,706 bytes, 5,284 objects
Snapshot 2 (30 min):  405,762 bytes, 5,288 objects
Snapshot 3 (3 hours): 406,026 bytes, 5,310 objects

ManagedObjectWrapperHolder: 1 instance (unchanged across all snapshots)

Memory remained stable throughout the test. The ManagedObjectWrapperHolder type you identified in your PerfView dump stayed at 1 instance.

To help us investigate further, could you please provide:

• A minimal sample project that reproduces the issue (the complete solution, not just the code snippet)
• The exact .NET SDK version you are using (dotnet --version)

We are attaching the text-converted reports from the gcdump snapshots, and the zipped source code we used for testing.

Thanks again for taking the time to report this.

report3.txt
WinFormsApp2.zip
report1.txt
report2.txt

[carltonshen-work]

@ricardobossan Thanks for the follow up. I've prepared a stripped-down project which I have confirmed to replicate this issue.

This is the package:
ShellExecutor_net10_leak_test.zip

In there, you can find my project code. There are 3 gcdump files, from different runs (on slight variance of the code) that confirms the leak exists. I've included the obj and bin folder in case there's some useful information for you to investigate.

Just run dotnet build to build it and get an executable that would trigger the issue. I have tried release build, which results in a similar result.

My local dotnet version is:

> dotnet --version 
10.0.102

And here's all the net10 packages I've installed on the dev box via chocolatey:

dotnet-10.0-aspnetruntime 10.0.1
dotnet-10.0-desktopruntime 10.0.1
dotnet-10.0-runtime 10.0.1
dotnet-10.0-sdk 10.0.101
dotnet-10.0-sdk-1xx 10.0.101

Sorry that I haven't checked your code - because it takes hours to confirm issue and strip-down code is done gradually, I think start from my code would allow me to provide an update sooner.