Memory leaks with C# app? How to stop?

Question

My app has huge memory leak and memory usage spiked from 40MB to 700MB after 1 day running. I'm coding with C# and I don't know how to stop leak. I suspect below 2 functions are main culprit.

SendLiveVideo: It captures from camera and send via socket.
ResizeImage: In order to save bandwidth it resizes image before I send out via socket.

My app calls 3-rd party library( LibImage, Libcapture) capture image from old webcams (4 cameras) and stream as video to list of LAN connected clients.

I already assigned null values to my *variables within finally statement upon exit of Sendvideo function in order to release memory, but it seems not working.

Do I need to use Dispose method instead?

this.timer_stream0.Interval = 30; /*I capture image and send to client this every 30 milseconds make it as video stream to human eye*/
this.timer_stream0.Tick += new System.EventHandler(this.timer_stream0_Tick);
private void timer_stream0_Tick(object sender, EventArgs e)
{
            ThreadPool.QueueUserWorkItem(SendLiveVideo, 0);
            ThreadPool.QueueUserWorkItem(SendLiveVideo, 1);
            ThreadPool.QueueUserWorkItem(SendLiveVideo, 2);
            ThreadPool.QueueUserWorkItem(SendLiveVideo, 3);
}
void SendLiveVideo(object state)
{
    LibImage image=new LibImage();
    LibCapture capture_camera=new LibCapture();
    int cam = (int)state;
System.Collections.ArrayList m_workerSocketList_Video =
ArrayList.Synchronized(new System.Collections.ArrayList());

    switch (cam)
    {
        case 0:
            {
                image = image0;
                capture_camera = capture_camera0;
                m_workerSocketList_Video = m_workerSocketList_Video0;
                break;
            }
        case 1:
            {
                image = image1;
                capture_camera = capture_camera1;
                m_workerSocketList_Video = m_workerSocketList_Video1;
                break;
            }
        case 2:
            {
                image = image2;
                capture_camera = capture_camera2;
                m_workerSocketList_Video = m_workerSocketList_Video2;
                break;
            }
        default:
            {
                image = image3;
                capture_camera = capture_camera3;
                m_workerSocketList_Video = m_workerSocketList_Video3;
                break;
            }
    }


    byte[] imageData=new byte[1000 * 1000 * 10];
    try
    {

        try
        {
            capture_camera.Capture(image);
        }
        catch
        {
            // objData = null;
            imageData = null;
            return;
        }

        imageData = image.SaveToMem(PNG);
        var stream = new MemoryStream(imageData);
        {
            var bitmap = new Bitmap(stream);
            bitmap = ResizeImage(bitmap, new Size(150, 112));
            //stream = null;
            MemoryStream streamnew = new MemoryStream();
            bitmap.Save(streamnew, ImageFormat.Png);
            imageData = streamnew.ToArray();
            bitmap = null;
            streamnew = null;
        }
        Socket workerSocket = null;
        for (int i = 0; i < m_workerSocketList_Video.Count; i++)
        {
            workerSocket = (Socket)m_workerSocketList_Video[i];
            if (workerSocket != null)
            {
                if (SocketConnected(workerSocket)) 
                {
                    workerSocket.Send(imageData);
                }
            }
        }


    }
    catch (SocketException se)
    {
        // MessageBox.Show(se.Message);
        return;
    }

    finally
    {
        image = null;
        capture_camera = null;
        imageData = null;
        m_workerSocketList_Video = null;
    }
}
private Bitmap ResizeImage(Bitmap imgToResize, Size size)
    {
        try
        {
            int sourceWidth = imgToResize.Width;
            int sourceHeight = imgToResize.Height;
        float nPercent = 0;
        float nPercentW = 0;
        float nPercentH = 0;

        nPercentW = ((float)size.Width / (float)sourceWidth);
        nPercentH = ((float)size.Height / (float)sourceHeight);

        if (nPercentH < nPercentW)
            nPercent = nPercentH;
        else
            nPercent = nPercentW;

        int destWidth = (int)(sourceWidth * nPercent);
        int destHeight = (int)(sourceHeight * nPercent);

        Bitmap b = new Bitmap(destWidth, destHeight, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
        b.SetResolution(200, 200);
        Graphics g = Graphics.FromImage((Image)b);
        g.InterpolationMode = InterpolationMode.HighQualityBicubic;
        g.CompositingQuality = CompositingQuality.HighSpeed;
        g.SmoothingMode = SmoothingMode.HighSpeed;

        g.DrawImage(imgToResize, 0, 0, destWidth, destHeight);
        g.Dispose();

        return b;
    }

Answer 1

Try taking a look at my SO answer here.

Basically, it is an approach of how to find the origin of the leak.
This is practically a copy-paste:

1. Open a memory profiler. I use perfmon. This article has some material about setting perfmon and @fmunkert also explains it rather well.
2. Locate an area in the code that you suspect that it is likely that the leak is in that area. This part is mostly depending on you having good guesses about the part of the code that is responsible for the issue.
3. Push the Leak to the extreme: Use labels and "goto" for isolating an area / function and repeat the suspicious code many times (a loop will work to. I find goto more convenient for this matter).
4. In the loop I have used a breakpoint that halted every 50 hits for examining the delta in the memory usage. Of course you can change the value to feet a noticeable leak change in your application.
5. If you have located the area that causes the leak, the memory usage should rapidly spike. If the Memory usage does not spike, repeat stages 1-4 with another area of code that you suspect being the root cause. If it does, continue to 6.
6. In the area you have found to be the cause, use same technique (goto + labels) to zoom in and isolate smaller parts of the area until you find the source of the leak.

Note that the down sides of this method are:

1. If you are allocating an object in the loop, it's disposal should be also contained in the loop.
2. If you have more than one source of leak, It makes it harder to spot (yet still possible)

Answer 2

• you have to use the using keyword whenever an IDisposable instance is used.

  using (MemoryStream streamnew = new MemoryStream()) // The same goes for your bitmap instance !

• you have to check on LibImage and LibCapture's implementations and the native libraries they're wrapping if it's the case.

• there is no need to instantiate all those three variables image, capture_camera and m_workerSocketList_Video since you're initializing them in your switch statement unless. This will lead to significant memory loss if the classes are native wrappers around libraries that poorly manage the memory they use.

• With this line of code,

  imageData = image.SaveToMem(PNG);

you don't need to initiate the imageData array if the SaveToMem function returns the right buffer !

Answer 3

I would use the

        using(Graphics g = Graphics.FromImage((Image)b))
        {
             g.InterpolationMode = InterpolationMode.HighQualityBicubic;
             g.CompositingQuality = CompositingQuality.HighSpeed;
             g.SmoothingMode = SmoothingMode.HighSpeed;

             g.DrawImage(imgToResize, 0, 0, destWidth, destHeight);
        }

        return b;

pattern on each type which implements the IDisposable, this way you can't forget to dispose anything?