Question

I have a C# application which launches another executable using Process.Start().

99% of the time this call works perfectly fine. After the application has run for quite some time though, Process.Start() will fail with the error message:

Insufficient system resources exist to complete the requested service

Initially I thought this must have been due to a memory leak in my program – I’ve profiled it fairly extensively and it doesn’t appear there’s a leak – the memory footprint will still be reasonable even when this message failed.

Immediately after a failure like this, if I print some of the system statistics it appears that I have over 600MB of RAM free, plenty of space on disk, and the CPU usage is effectively at 0%.

Is there some other system resource I haven’t thought of? Am I running into a memory limit within the .NET VM?

Edit2:

I opened up the application in SysInternals Process Explorer and it looks like I’m leaking Handles left and right:

Handles Used: 11,950,352 (!)
GDI Handles: 26
USER Handles: 22

What’s strange here is that the Win32 side of handles seem very reasonable, but somehow my raw handle count has exploded waaaaay out of control. Any ideas what could cause a Handle leak like this? I was originally convinced it was Process.Start() but that would be USER handles, wouldn’t it?

Edit:

Here’s an example of how I’m creating the process:

var pInfo = new ProcessStartInfo(path, ClientStartArguments)
        {
            UseShellExecute = false,
            WorkingDirectory = workingDirectory
        };    
ClientProcess = Process.Start(pInfo);

Here’s an example of how I kill the same process (later in the program after I have interacted with the process):

Process[] clientProcesses = Process.GetProcessesByName(ClientProcessName);
if (clientProcesses.Length > 0)
{
     foreach (var clientProcess in clientProcesses.Where(
              clientProcess => clientProcess.HasExited == false))
     {
        clientProcess.Kill();
     }
}

Answer 1

The problem here is with retained process handles. As we can see from your later edits you are keeping a reference to the Process object returned by Process.Start(). As mentioned in the documentation of Process:

Like many Windows resources, a process is also identified by its handle, which might not be unique on the computer. A handle is the generic term for an identifier of a resource. The operating system persists the process handle, which is accessed through the Handle property of the Process component, even when the process has exited. Thus, you can get the process’s administrative information, such as the ExitCode (usually either zero for success or a nonzero error code) and the ExitTime. Handles are an extremely valuable resource, so leaking handles is more virulent than leaking memory.

I especially like the use of the word virulent. You need to dispose and release the reference to Process.

Also check out this excellent question and it’s corresponding answer: Not enough memory or not enough handles?