Why does this method consume so much memory? Or rather, why isn't GC freeing the memory?

Question

I'm building some software that requires image panning, zooming, and brightness controls. I set up a small project to to build a simple brightness control after finding a lot of examples online, so please ignore that I'm doing everything in the main form

When I start to use the trackbar controller, which fires the event below when the value (-100 to 100) is changed, memory usage stacks up into the Gigabytes in seconds. It'll then sit there and never free the memory. Moving the trackbar again eats up even more memory

private void trackBarBrightness_EditValueChanged(object sender, EventArgs e)
    {
        float value = trackBarBrightness.Value * 0.01f;
        float[][] colorMatrixElements =
        {
            new float[] {
                1,
                0,
                0,
                0,
                0
            },
            new float[] {
                0,
                1,
                0,
                0,
                0
            },
            new float[] {
                0,
                0,
                1,
                0,
                0
            },
            new float[] {
                0,
                0,
                0,
                1,
                0
            },
            new float[] {
                value,
                value,
                value,
                0,
                1
            }
        };

        ColorMatrix colorMatrix = new ColorMatrix(colorMatrixElements);
        ImageAttributes imageAttributes = new ImageAttributes();

        imageAttributes.SetColorMatrix(colorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);

        //Image img = this.pictureEdit.Image;
        Image img = originalImage;
        Graphics g = default(Graphics);
        Bitmap bm = new Bitmap(Convert.ToInt32(img.Width), Convert.ToInt32(img.Height));
        g = Graphics.FromImage(bm);
        g.DrawImage(img, new Rectangle(0, 0, bm.Width, bm.Height), 0, 0, bm.Width, bm.Height, GraphicsUnit.Pixel, imageAttributes);
        pictureEdit.Image = bm;
    }

Any guidance would be much appreciated

Answer 1

The issue is that you are not calling Dispose on your Bitmap. A Bitmap in .Net is essentially just a small managed object that wraps around a large unmanged GDI+ bitmap (source). It is this GDI+ bitmap that is storing the pixel data and, therefore, responsible for the memory consumption. The managed .Net Bitmap, being just a wrapper, is much smaller in comparison.

The reason GC.Collect() is freeing the memory is because you are forcing the GC to free all those bitmaps that are no longer being referenced which is in turn releasing all the unmanaged memory they are pointing to. The reason the GC is not doing this for you automatically is because the GC only tracks managed memory not unmanaged memory. So from the GC's point of view all these managed bitmaps you have left laying around are small and not taking up a lot of room so it is not important that it collect them. When, in fact, they are quite large. From the MSDN:

If a small managed object allocates a large amount of unmanaged memory, the runtime takes into account only the managed memory, and thus underestimates the urgency of scheduling garbage collection.

By calling Dispose on your Bitmap when you no longer need it you will immediately free the unmanaged memory being used by the GDI+ bitmap. The managed .Net Bitmap will still hang around until the GC gets around to collecting it but who cares, that's tiny.

Answer 2

Bitmap is inheriting from Image and Image has a finalizer! That makes it automatically Gen1 when created and can take minutes to dispose and free if the GC does not feel memory pressure.

The fast pace of updating is actually creating many instances and they have to be collected by finalizer thread one by one. Sometimes it takes even 15 minutes, sometimes sooner.

The solution is to limit the number of Bitmaps at any moment and there is needed only one at any moment, latest one and when replaced, the previous can be disposed and the current presented until next update.

Then you should do something like this:

private void trackBarBrightness_EditValueChanged(object sender, EventArgs e)
{
    //your current code here up to (excluding): pictureEdit.Image = bm;
    IDisposable PreviousImage = pictureEdit.Image;
    pictureEdit.Image = bm;
    PreviousImage?.Dispose();
}

or this, if the PictureBox is write only:

private IDisposable PreviousImage {get;set;}

private void trackBarBrightness_EditValueChanged(object sender, EventArgs e)
{
    //your current code here up to (excluding): pictureEdit.Image = bm;
    pictureEdit.Image = bm;
    PreviousImage?.Dispose();
    PreviousImage = bm;
}

Answer 3

Don't see you are using any loops and so not sure but you can consider using a memory profiler and see but I see you are not disposing off the created Image object all. I mean the below two lines. You should explicitly call Dispose() on them or use a Using(...) { ... } construct for better disposal

Image img = originalImage;
Graphics g = default(Graphics);