Question

public void DoPing(object state)
{
    string host = state as string;
    m_lastPingResult = false;
    while (!m_pingThreadShouldStop.WaitOne(250))
    {
        Ping p = new Ping();
        try
        {
            PingReply reply = p.Send(host, 3000);
            if (reply.Status == IPStatus.Success)
            {
                m_lastPingResult = true;
            }
            else
            {
                m_lastPingResult = false;
            }
        }
        catch
        {

        }
        numping = numping + 1;
    }
}

Any idea why this code gives me a memory leak? I can see it’s this code as changing the wait value to smaller or larger values increases the rate of the memory usage. Does any one have any idea how to resolve it? or how to see what part of the code is causing it?

Answer 1

In some garbage collected languages, there is a limitation that the object isn’t collected if the method that created it still hasn’t exited.

I believe .net works this way in debug mode. Quoting from this article; note the bolded statement.

http://www.simple-talk.com/dotnet/.net-framework/understanding-garbage-collection-in-.net/

A local variable in a method that is currently running is considered
to be a GC root. The objects referenced by these variables can always
be accessed immediately by the method they are declared in, and so
they must be kept around. The lifetime of these roots can depend on
the way the program was built. In debug builds, a local variable lasts
for as long as the method is on the stack. In release builds, the JIT
is able to look at the program structure to work out the last point
within the execution that a variable can be used by the method and
will discard it when it is no longer required. This strategy isn’t
always used and can be turned off, for example, by running the program
in a debugger.