Use binding in transform cause memory leak in VS 2022

[yll690]

• .NET Core Version: 6.0, 4.5
• Windows version: 19044.1826
• Does the bug reproduce also in WPF for .NET Framework 4.8?: Yes in 4.5.
• Is this bug related specifically to tooling in Visual Studio (e.g. XAML Designer, Code editing, etc...)? Yes, only in VS2022.

Problem description:
I have a DataTemplate which contains a RotateTransform whose Angle is bound to the model. When I add models to a ItemsControl and then remove them, the memory usage won't fall to initial value and the object count will increase.

Actual behavior:
As the sample code below, when the button is clicked, 10,000 models will be added to the window and then be removed. But the memory usage and object count remains. Most of the objects are WeakReference, ConditionalWeakTable<Object, Object>, ConditionalWeakTable+Container<Object, Object>, WeakEventManager+ListenerList<EventArgs>.

Timeline	memory	object count
initial	61M	34196
clicked	133M	155440

Expected behavior:
If I delete the transform or delete the binding, the memory usage and object count will decrease.

Timeline	memory	object count
initial	62M	34227
clicked	107M	34461

Minimal repro:
MainWindow.xaml

<Window x:Class="WPFTransformBindingMemoryLeak.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WPFTransformBindingMemoryLeak"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Window.Resources>
        <DataTemplate DataType="{x:Type local:Shape}">
            <Border Background="SandyBrown">
                <Border.RenderTransform>
                    <RotateTransform Angle="{Binding Angle}"/>
                </Border.RenderTransform>
                <TextBlock Text="The Shape"/>
            </Border>
        </DataTemplate>
    </Window.Resources>
    <Grid>
        <Button Content="start" Name="startB" Click="startB_Click" Width="100" Height="100"/>
        <ItemsControl x:Name="container"/>
    </Grid>
</Window>

MainWindow.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows;

namespace WPFTransformBindingMemoryLeak
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void startB_Click(object sender, RoutedEventArgs e)
        {
            for (int i = 0; i < 100; i++)
            {
                List<Shape> packages = new List<Shape>();
                for (int j = 0; j < 100; j++)
                    packages.Add(new Shape());
                Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Background, new Action(() =>
                {
                    for (int j = 0; j < 100; j++)
                        container.Items.Add(packages[j]);
                }));
                Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Background, new Action(() =>
                {
                    for (int j = 0; j < 100; j++)
                        container.Items.Remove(packages[j]);
                }));
            }
            Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.ApplicationIdle, new Action(() =>
            {
                GC.Collect();
            }));
        }
    }

    public class Shape : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler? PropertyChanged;
        private double angle;
        public double Angle
        {
            get { return angle; }
            set
            {
                angle = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Angle)));
            }
        }

    }
}

[yll690]

My project use framework 4.5 which seems won't be updated any more so is there any workaround to solve the problem?

[marbel82]

In your example, I found no memory leak, which doesn't mean it won't be in a larger application.

When you see WeakReference or ***Weak***, this object will be removed, but in my experience WPF clear some references after a few seconds and also GC.Collect() does not guarantee that all unused memory will be freed.

What I do:

// Change:
        GC.Collect();

// Into:
        MessageBox.Show("Work completed");

// Add "GC" button and click handler
        private void GC_Click(object sender, RoutedEventArgs e)
        {
            double memBefore = GC.GetTotalMemory(false) / 1048576.0;

            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();

            double memAfter = GC.GetTotalMemory(true) / 1048576.0;

            MessageBox.Show($"Before: {memBefore:#,#.00} MB\nAfter: {memAfter:#,#.00} MB");
        }

Then I run app, and click "start", wait for "Work completed", than wait a few seconds and click GC button. I have repeated this operation many times. I even clicked "start" 3 times in a row without waiting for "Work completed".

These are my results in the .NET 6 project:

And these are in the .NET Framework 4.5 project:

In both cases, the number of objects remains at a similar level.

[yll690]

@marbel82 Thank you for your help and detailed tests. But even with your enhanced GC method, the object count won't fall back in my test. I follow the same test flow with you and it results in:

Could you upload the full test project? This is my test project:
WPFTransformBindingMemoryLeak.zip

[marbel82]

@yll690 I take your project, and my results are the same as before. This time I don't use "gc" button. I let the garbabe collector do the job for me.

Show me your memory shapshots after 1000 seconds of using your app.

[yll690]

@marbel82 If I don't click the gc button, the object count will increase to 300k+ and never fall back. It's nearly double of your max count. And if I use GC, it will fall to 150k but won't fall further (like the previous test).

[yll690]

I finally find out why. It's VS2022's problem. If I use the VS2019, the problem disappear, no matter what version of .Net I used.

[yll690]

Forgot to mention that I have posted a problem to Visual Studio Feedback: Use binding in transform cause memory leak in 2022. You could vote for it.

[lindexi]

I test your code with dotMemory. Maybe it is memory leak.

[asundheim]

If you open up the problematic snapshots, you'll see VS types holding on to your memory (such as Microsoft.VisualStudio.DesignTools.WpfTap.*), which I've been told is due to XAML Hot Reload. We're working on adding a warning to indicate the snapshot may not accurately reflect memory usage due to this, but you can try disabling XAML Hot Reload and seeing if that resolves your issue.