Process::Start Method (ProcessStartInfo^)


The .NET API Reference documentation has a new home. Visit the .NET API Browser on to see the new experience.

Starts the process resource that is specified by the parameter containing process start information (for example, the file name of the process to start) and associates the resource with a new Process component.

Namespace:   System.Diagnostics
Assembly:  System (in System.dll)

static Process^ Start(
	ProcessStartInfo^ startInfo


Type: System.Diagnostics::ProcessStartInfo^

The ProcessStartInfo that contains the information that is used to start the process, including the file name and any command-line arguments.

Return Value

Type: System.Diagnostics::Process^

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.

Exception Condition

No file name was specified in the startInfo parameter's FileName property.


The UseShellExecute property of the startInfo parameter is true and the RedirectStandardInput, RedirectStandardOutput, or RedirectStandardError property is also true.


The UseShellExecute property of the startInfo parameter is true and the UserName property is not null or empty or the Password property is not null.


The startInfo parameter is null.


The process object has already been disposed.


The file specified in the startInfo parameter's FileName property could not be found.


An error occurred when opening the associated file.


The sum of the length of the arguments and the length of the full path to the process exceeds 2080. The error message associated with this exception can be one of the following: "The data area passed to a system call is too small." or "Access is denied."

Use this overload to start a process resource by specifying a ProcessStartInfo instance. The overload associates the resource with a new Process object.


If the address of the executable file to start is a URL, the process is not started and null is returned.

This overload lets you start a process without first creating a new Process instance. Using this overload with a ProcessStartInfo parameter is an alternative to the explicit steps of creating a new Process instance, setting its StartInfo properties, and calling Start for the Process instance.

Using a ProcessStartInfo instance as the parameter lets you call Start with the most control over what is passed into the call to start the process. If you need to pass only a file name or a file name and arguments, it is not necessary to create a new ProcessStartInfo instance, although that is an option. The only Process::StartInfo property that must be set is the FileName property. The FileName property does not need to represent an executable file. It can be of any file type whose extension has been associated with an application that is installed on the system. For example, the FileName property can have a .txt extension if you have associated text files with an editor, such as Notepad, or it can have a .doc extension if you have associated.doc files with a word processing tool, such as Microsoft Word.

You can start a ClickOnce application by specifying the location (for example, a Web address) from which you originally installed the application. Do not start a ClickOnce application by specifying its installed location on your hard drive.

If the ProcessStartInfo::UserName and ProcessStartInfo::Password properties are set, the unmanaged CreateProcessWithLogonW function is called, which starts the process in a new window even if the ProcessStartInfo::CreateNoWindow property value is true or the ProcessStartInfo::WindowStyle property value is ProcessWindowStyle::Hidden. If the ProcessStartInfo::Domain property is null, the ProcessStartInfo::UserName property must be in UPN format, user@DNS_domain_name.

Unlike the other overloads, the overload of Start that has no parameters is not a static member. Use that overload when you have already created a Process instance, specified start information (including the file name), and want to start a process resource and associate it with the existing Process instance. Use one of the static overloads when you want to create a new Process component rather than start a process for an existing component. Both this overload and the overload that has no parameters allow you to specify the start information for the process resource by using a ProcessStartInfo instance.

If you have a path variable declared in your system using quotes, you must fully qualify that path when starting any process found in that location. Otherwise, the system will not find the path. For example, if c:\mypath is not in your path, and you add it using quotation marks: path = %path%;"c:\mypath", you must fully qualify any process in c:\mypath when starting it.


ASP.NET Web page and server control code executes in the context of the ASP.NET worker process on the Web server. If you use the Start method in an ASP.NET Web page or server control, the new process executes on the Web server with restricted permissions. The process does not start in the same context as the client browser, and does not have access to the user desktop.

Whenever you use Start to start a process, you might need to close it or you risk losing system resources. Close processes using CloseMainWindow or Kill. You can check whether a process has already been closed by using its HasExited property.

A note about apartment states in managed threads is necessary here. When UseShellExecute is true on the startInfo parameter, make sure you have set a threading model on your application by setting the attribute [STAThread] on the main() method. Otherwise, a managed thread can be in an unknown state or put in the MTA state, the latter of which conflicts with UseShellExecute being true. Some methods require that the apartment state not be unknown. If the state is not explicitly set, when the application encounters such a method, it defaults to MTA, and once set, the apartment state cannot be changed. However, MTA causes an exception to be thrown when the operating system shell is managing the thread.

The following example first spawns an instance of Internet Explorer and displays the contents of the Favorites folder in the browser. It then starts some other instances of Internet Explorer and displays some specific pages or sites. Finally it starts Internet Explorer with the window being minimized while navigating to a specific site.

For additional examples of other uses of this method, refer to the individual properties of the ProcessStartInfo class.

#using <System.dll>

using namespace System;
using namespace System::Diagnostics;
using namespace System::ComponentModel;

// Opens the Internet Explorer application.
void OpenApplication(String^ myFavoritesPath)
    // Start Internet Explorer. Defaults to the home page.

    // Display the contents of the favorites folder in the browser.

// Opens urls and .html documents using Internet Explorer.
void OpenWithArguments()
    // url's are not considered documents. They can only be opened
    // by passing them as arguments.
    Process::Start("IExplore.exe", "");

    // Start a Web page using a browser associated with .html and .asp files.
    Process::Start("IExplore.exe", "C:\\myPath\\myFile.htm");
    Process::Start("IExplore.exe", "C:\\myPath\\myFile.asp");

// Uses the ProcessStartInfo class to start new processes,
// both in a minimized mode.
void OpenWithStartInfo()
    ProcessStartInfo^ startInfo = gcnew ProcessStartInfo("IExplore.exe");
    startInfo->WindowStyle = ProcessWindowStyle::Minimized;
    startInfo->Arguments = "";

int main()
    // Get the path that stores favorite links.
    String^ myFavoritesPath = Environment::GetFolderPath(Environment::SpecialFolder::Favorites);


for full trust for the immediate caller. This member cannot be used by partially trusted code.

.NET Framework
Available since 1.1
Return to top