In what cases does the Process.Start() method return false?

Question

From MSDN:

The return value true indicates that a new process resource was started. If the process resource specified by the FileName member of the StartInfo property is already running on the computer, no additional process resource is started. Instead, the running process resource is reused and false is returned.

Trying something like this:

var info = new ProcessStartInfo {FileName = @"CMD"};

var p1 = new Process
{
     StartInfo = info
};

var result = p1.Start(); //true
result = p1.Start(); //true

var p2 = new Process
{
    StartInfo = info
};

result = p2.Start(); //true

Have the same result if I'm using FilePath = @"c:\myapp.exe" instead of CMD.

In what cases does it return false?

Possible duplicate of [Process.Start and allocated resources](http://stackoverflow.com/questions/10884136/process-start-and-allocated-resources) — Sinatr, Oct 09 '15 at 15:42
FWIW, Depending on whether or not you use Shell Execute to begin the process, here's the actual code that determines it: [Without Shell Execute](http://referencesource.microsoft.com/#System/services/monitoring/system/diagnosticts/Process.cs,2167), [With Shell Execute](http://referencesource.microsoft.com/#System/services/monitoring/system/diagnosticts/Process.cs,2278). — James Thorpe, Oct 09 '15 at 15:42

Ron Beyer · Accepted Answer · 2015-10-09T15:50:57.787

If you take a look at the reference source, you'll see how Process.Start works:

http://referencesource.microsoft.com/System/R/c50d8ac0eb7bc0d6.html

That is one of two methods called when you call Process.Start. Notice near the bottom where it returns the value true or false. False is only returned if, after starting the process, it cannot obtain the handle for the process that was started.

In order to start the process, it uses NativeMethods.CreateProcess which you can find the source of here: http://referencesource.microsoft.com/System/compmod/microsoft/win32/NativeMethods.cs.html#9c52a5ca5f3eeea3

Which is just the method prototype for Kernel32.CreateProcess, which the API is found here: https://msdn.microsoft.com/en-us/library/windows/desktop/ms682425(v=vs.85).aspx

If you look at the return values, it says:

If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.

I can't find anything in the API for CreateProcess that says it fails if the requested process is already running, perhaps if the process failed to start because it is a single instance application (like Outlook) then it may fail, but for multiple instance applications like the command prompt, it shouldn't fail to create a handle to the process.

So, after saying all that, it is possible that the MSDN documentation is not entirely correct, I don't have the link you have, but for the Process.Start(StartInfo), MSDN says this about the return value:

A new Process that is associated with the process resource, or null if no process resource is started. Note that a new process that’s started alongside already running instances of the same process will be independent from the others. In addition, Start may return a non-null Process with its HasExited property already set to true. In this case, the started process may have activated an existing instance of itself and then exited.

(Emphasis added by me). It doesn't say the call will fail if its already running.

For Process.Start(), it says:

Return Value Type: System.Boolean true if a process resource is started; false if no new process resource is started (for example, if an existing process is reused).

So it says if an existing process is reused, this is entirely up to the application being started or the method of starting it.

So in what practical cases it can be false? I tried both outlook and running windows service (like Sql Server) everything returned `True`. — Vova, Oct 09 '15 at 15:50
@AlexK. I think I fixed that in the edit at the end, will add the link for the instance method in a second. — Ron Beyer, Oct 09 '15 at 15:50
@Vova It returns false when it fails to create a process handle for the process. Outlook may be a little different since it is a single instance application, but will create multiple windows. I'm not sure if reuse only happens when the `Process` is used as a `Component` on a forms application for example, I haven't run code tests to verify personally. — Ron Beyer, Oct 09 '15 at 15:53
It seems like the other case not involving `CreateProcess` (`startInfo.UseShellExecute`) pretty likely not to create a new process. — , Oct 09 '15 at 15:58
If you are interested in getting false in practice, you can try to rename some .txt file into .exe and try to run using `Process.Start`. It will return `False` in this case. — Vova, Oct 09 '15 at 15:59

score 8 · Answer 2 · answered Oct 09 '15 at 16:47

You can technically get a false return when you use ProcessStartInfo.UseShellExecute = true (the default) and you launch the process by passing a document filename. And the shell is somehow able to figure out to pass the document open request to an already running instance of the process.

The only documented case of this is opening a web page in Internet Explorer. There might be other ones, probably having something to do with legacy DDE activation. That's a guess.

This is otherwise a specific case of a general problem with Process.Start(), there are lots of single-instance apps around. The Office apps as the most common example. The most typical behavior you'd observe is that the process very quickly terminates again. It just detected that the app was already running and used process-interop to ask the running instance to open the document. The kind of feature also supported in .NET.

You'll have no idea which specific process is showing the document unless you know it is a single-instance app and its process name so you have some hope of finding it back with Process.GetProcessesByName(). This is however not fail-safe, there might be an unrelated process running that happens to have the same name. Advantage of getting false is that you know there's no point in waiting for it to terminate.

In what cases does the Process.Start() method return false?

2 Answers2

Linked