Process.Start Method (System.Diagnostics) | Microsoft Learn

link之家

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

Parameters

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.

Attributes

CLSCompliantAttribute SupportedOSPlatformAttribute

An error occurred when opening the associated file.

The file specified in the fileName could not be found.

The sum of the length of the arguments and the length of the full path to the associated file 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."

Remarks

Use this overload to create a new process and its primary thread by specifying its file name, command-line arguments, user name, password, and domain. The new process then runs the specified executable file in the security context of the specified credentials (user, domain, and password).

Important

Calling this method with untrusted data is a security risk. Call this method only with trusted data. For more information, see Validate All Inputs .

When the executable file is located on a remote drive, you must identify the network share by using a uniform resource identifier (URI), not a linked drive letter.

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. The overload is an alternative to the explicit steps of creating a new Process instance, setting the FileName , Arguments , UserName , Password , and Domain properties of the StartInfo property, and calling Start for the Process instance.

Similarly, in the same way that the Run dialog box can accept an executable file name with or without the .exe extension, the .exe extension is optional in the fileName parameter. For example, you can set the fileName parameter to either "Notepad.exe" or "Notepad". If the fileName parameter represents an executable file, the arguments parameter might represent a file to act upon, such as the text file in Notepad.exe myfile.txt .

The file name must represent an executable file in the Start overloads that have userName , password , and domain parameters.

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.

public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName, System::String ^ userName, System::Security::SecureString ^ password, System::String ^ domain);

[System.CLSCompliant(false)]
[System.Runtime.Versioning.SupportedOSPlatform("windows")]
public static System.Diagnostics.Process? Start (string fileName, string userName, System.Security.SecureString password, string domain);

[System.CLSCompliant(false)]
public static System.Diagnostics.Process Start (string fileName, string userName, System.Security.SecureString password, string domain);

public static System.Diagnostics.Process Start (string fileName, string userName, System.Security.SecureString password, string domain);

[<System.CLSCompliant(false)>]
[<System.Runtime.Versioning.SupportedOSPlatform("windows")>]
static member Start : string * string * System.Security.SecureString * string -> System.Diagnostics.Process

[<System.CLSCompliant(false)>]
static member Start : string * string * System.Security.SecureString * string -> System.Diagnostics.Process

static member Start : string * string * System.Security.SecureString * string -> System.Diagnostics.Process

Public Shared Function Start (fileName As String, userName As String, password As SecureString, domain As String) As Process

Parameters

Attributes

CLSCompliantAttribute SupportedOSPlatformAttribute

Examples

The following code example shows the use of this overload to start an executable file and also demonstrates the throwing of a Win32Exception when an attempt is made to start an application associated with a nonexecutable file.


   // NOTE: This example requires a text.txt file file in your Documents folder
using System;
using System.Diagnostics;
using System.Security;
using System.ComponentModel;
class Example
    static void Main()
        Console.Write("Enter your domain: ");
        string domain = Console.ReadLine();
        Console.Write("Enter you user name: ");
        string uname = Console.ReadLine();
        Console.Write("Enter your password: ");
        SecureString password = new SecureString();
        ConsoleKeyInfo key;
            key = Console.ReadKey(true);
            // Ignore any key out of range.
            if (((int)key.Key) >= 33 && ((int)key.Key <= 90) && key.Key != ConsoleKey.Enter)
                // Append the character to the password.
                password.AppendChar(key.KeyChar);
                Console.Write("*");
            // Exit if Enter key is pressed.
        } while (key.Key != ConsoleKey.Enter);
        Console.WriteLine();
            Console.WriteLine("\nTrying to launch NotePad using your login information...");
            Process.Start("notepad.exe", uname, password, domain);
        catch (Win32Exception ex)
            Console.WriteLine(ex.Message);
        string path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\";
            // The following call to Start succeeds if test.txt exists.
            Console.WriteLine("\nTrying to launch 'text.txt'...");
            Process.Start(path + "text.txt");
        catch (Win32Exception ex)
            Console.WriteLine(ex.Message);
            // Attempting to start in a shell using this Start overload fails. This causes
            // the following exception, which is picked up in the catch block below:
            // The specified executable is not a valid application for this OS platform.
            Console.WriteLine("\nTrying to launch 'text.txt' with your login information...");
            Process.Start(path + "text.txt", uname, password, domain);
        catch (Win32Exception ex)
            Console.WriteLine(ex.Message);
        finally
            password.Dispose();
   
    ' This sample requires a text.txt file file in your documents folder.
' You'll also need to set the startup object in the project to Sub Main.
Imports System.Diagnostics
Imports System.Security
Imports System.ComponentModel
Module Program
    Sub Main()
        Console.Write("Enter your domain: ")
        Dim domain As String = Console.ReadLine()
        Console.Write("Enter you user name: ")
        Dim uname As String = Console.ReadLine()
        Console.Write("Enter your password: ")
        Dim password As New SecureString()
        Dim key As ConsoleKeyInfo
            key = Console.ReadKey(True)
            ' Ignore any key out of range.
            If key.Key >= 33 AndAlso key.Key <= 90 AndAlso key.Key <> ConsoleKey.Enter Then
                ' Append the character to the password.
                password.AppendChar(key.KeyChar)
                Console.Write("*")
            End If
            ' Exit if Enter key is pressed.
        Loop While key.Key <> ConsoleKey.Enter
        Console.WriteLine()
            Console.WriteLine(vbCrLf + "Trying to launch NotePad using your login information...")
            Process.Start("notepad.exe", uname, password, domain)
        Catch ex As Win32Exception
            Console.WriteLine(ex.Message)
        End Try
        Dim path As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\"
            ' The following call to Start succeeds if test.txt exists.
            Console.WriteLine(vbCrLf + "Trying to launch 'text.txt'...")
            Process.Start(path + "Text.txt")
        Catch ex As Win32Exception
            Console.WriteLine(ex.Message)
        End Try
            ' Attempting to start in a shell using this Start overload fails. This causes
            ' the following exception, which is picked up in the catch block below:
            ' The specified executable is not a valid application for this OS platform.
            Console.WriteLine(vbCrLf + "Trying to launch 'text.txt' with your login information...")
            Process.Start(path + "Text.txt", uname, password, domain)
        Catch ex As Win32Exception
            Console.WriteLine(ex.Message)
        Finally
            password.Dispose()
        End Try
    End Sub
End Module
    
     Remarks
    
    
     Use this overload to create a new process and its primary thread by specifying its file name, user name, password, and domain. The new process then runs the specified executable file in the security context of the specified credentials (user, domain, and password).
    




    

    
     Important
    
    
     Calling this method with untrusted data is a security risk. Call this method only with trusted data. For more information, see
     
      Validate All Inputs
     
     .
    
    
     When the executable file is located on a remote drive, you must identify the network share by using a uniform resource identifier (URI), not a linked drive letter.
    
    
     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. The overload is an alternative to the explicit steps of creating a new
     
      Process
     
     instance, setting the
     
      FileName
     
     ,
     
      UserName
     
     ,
     
      Password
     
     , and
     
      Domain
     
     properties of the
     
      StartInfo
     
     property, and calling
     
      Start
     
     for the
     
      Process
     
     instance.
    
    
     Similarly, in the same way that the
     
      Run
     
     dialog box can accept an executable file name with or without the .exe extension, the .exe extension is optional in the
     
      fileName
     
     parameter. For example, you can set the
     
      fileName
     
     parameter to either "Notepad.exe" or "Notepad". If the
     
      fileName
     
     parameter represents an executable file, the
     
      arguments
     
     parameter might represent a file to act upon, such as the text file in
     
      Notepad.exe myfile.txt
     
     .
    
    
     The file name must represent an executable file in the
     
      Start
     
     overloads that have
     
      userName
     
     ,
     
      password
     
     , and
     
      domain
     
     parameters.
    
    
     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.
    
    public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName, System::String ^ arguments);
    public static System.Diagnostics.Process Start (string fileName, string arguments);
    [System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process Start (string fileName, string arguments);
    [System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
public static System.Diagnostics.Process Start (string fileName, string arguments);
    static member Start : string * string -> System.Diagnostics.Process
    [<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string * string -> System.Diagnostics.Process
    [<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
static member Start : string * string -> System.Diagnostics.Process
    Public Shared Function Start (fileName As String, arguments As String) As Process
    
     Parameters
    
    
     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.
    
    
     Attributes
    
    
     UnsupportedOSPlatformAttribute
    
    
     SupportedOSPlatformAttribute
    
    
     An error occurred when opening the associated file.
    
    
     The file specified in the
     
      fileName
     
     could not be found.
    
    
     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."
    
    
     Examples
    
    
     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.
    
    
     #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.
    Process::Start("IExplore.exe");
    // Display the contents of the favorites folder in the browser.
    Process::Start(myFavoritesPath);
// Opens urls and .html documents using Internet Explorer.
void OpenWithArguments()
    // URLs are not considered documents. They can only be opened
    // by passing them as arguments.
    Process::Start("IExplore.exe", "www.northwindtraders.com");
    // 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;
    Process::Start(startInfo);
    startInfo->Arguments = "www.northwindtraders.com";
    Process::Start(startInfo);
int main()
    // Get the path that stores favorite links.
    String^ myFavoritesPath = Environment::GetFolderPath(Environment::SpecialFolder::Favorites);
    OpenApplication(myFavoritesPath);
    OpenWithArguments();
    OpenWithStartInfo();
     
      using System;
using System.Diagnostics;
using System.ComponentModel;
namespace MyProcessSample
    class MyProcess
        // Opens the Internet Explorer application.
        void OpenApplication(string myFavoritesPath)
            // Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe");
            // Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath);
        // 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", "www.northwindtraders.com");
            // 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 = new ProcessStartInfo("IExplore.exe");
            startInfo.WindowStyle = ProcessWindowStyle.Minimized;
            Process.Start(startInfo);
            startInfo.Arguments = "www.northwindtraders.com";
            Process.Start(startInfo);
        static void Main()
            // Get the path that stores favorite links.
            string myFavoritesPath =
                Environment.GetFolderPath(Environment.SpecialFolder.Favorites);
            MyProcess myProcess = new MyProcess();
            myProcess.OpenApplication(myFavoritesPath);
            myProcess.OpenWithArguments();
            myProcess.OpenWithStartInfo();
      
       Imports System.Diagnostics
Imports System.ComponentModel
Namespace MyProcessSample
    Class MyProcess
        ' Opens the Internet Explorer application.
        Public Sub OpenApplication(myFavoritesPath As String)
            ' Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe")
            ' Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath)
        End Sub
        ' Opens URLs and .html documents using Internet Explorer.
        Sub OpenWithArguments()
            ' URLs are not considered documents. They can only be opened
            ' by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com")
            ' 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")
        End Sub
        ' Uses the ProcessStartInfo class to start new processes,
        ' both in a minimized mode.
        Sub OpenWithStartInfo()
            Dim startInfo As New ProcessStartInfo("IExplore.exe")
            startInfo.WindowStyle = ProcessWindowStyle.Minimized
            Process.Start(startInfo)
            startInfo.Arguments = "www.northwindtraders.com"
            Process.Start(startInfo)
        End Sub
        Shared Sub Main()
            ' Get the path that stores favorite links.
            Dim myFavoritesPath As String = Environment.GetFolderPath(Environment.SpecialFolder.Favorites)
            Dim myProcess As New MyProcess()
            myProcess.OpenApplication(myFavoritesPath)
            myProcess.OpenWithArguments()
            myProcess.OpenWithStartInfo()
        End Sub
    End Class
End Namespace 'MyProcessSample
       
        Remarks
       
       
        Use this overload to start a process resource by specifying its file name and command-line arguments. The overload associates the resource with a new
        
         Process
        
        object.
       
       
        Important
       
       
        Calling this method with untrusted data is a security risk. Call this method only with trusted data. For more information, see
        
         Validate All Inputs
        
        .
       
       
        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. The overload is an alternative to the explicit steps of creating a new
        
         Process
        
        instance, setting the
        
         FileName
        
        and
        
         Arguments
        
        members of the
        
         StartInfo
        
        property, and calling
        
         Start
        
        for the
        
         Process
        
        instance.
       




    

       
        Starting a process by specifying its file name and arguments is similar to typing the file name and command-line arguments in the
        
         Run
        
        dialog box of the Windows
        
         Start
        
        menu. Therefore, the file name does not need to represent an executable file. It can be of any file type for which the extension has been associated with an application installed on the system. For example the file name can have a .txt extension if you have associated text files with an editor, such as Notepad, or it can have a .doc if you have associated .doc files with a word processing tool, such as Microsoft Word. Similarly, in the same way that the
        
         Run
        
        dialog box can accept an executable file name with or without the .exe extension, the .exe extension is optional in the
        
         fileName
        
        parameter. For example, you can set the
        
         fileName
        
        parameter to either "Notepad.exe" or "Notepad". If the
        
         fileName
        
        parameter represents an executable file, the
        
         arguments
        
        parameter might represent a file to act upon, such as the text file in
        
         Notepad.exe myfile.txt
        
        . If the
        
         fileName
        
        parameter represents a command (.cmd) file, the
        
         arguments
        
        parameter must include either a "
        
         /c
        
        " or "
        
         /k
        
        " argument to specify whether the command window exits or remains after completion.
       
       
        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 and specified start information (including the file name), and you 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 file name of the process resource to start and command-line arguments to pass.
       
       
        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 process component's
        
         StartInfo
        
        property, 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.
       
       public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName);
       public static System.Diagnostics.Process Start (string fileName);
       [System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process Start (string fileName);
       [System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
public static System.Diagnostics.Process Start (string fileName);
       static member Start : string -> System.Diagnostics.Process
       [<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string -> System.Diagnostics.Process
       [<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
static member Start : string -> System.Diagnostics.Process
       Public Shared Function Start (fileName As String) As Process
       
        Parameters
       
       
        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.
       
       
        Attributes
       
       
        UnsupportedOSPlatformAttribute
       
       
        SupportedOSPlatformAttribute
       
       
        Examples
       
       
        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.
       
       
        #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.
    Process::Start("IExplore.exe");
    // Display the contents of the favorites folder in the browser.
    Process::Start(myFavoritesPath);
// Opens urls and .html documents using Internet Explorer.
void OpenWithArguments()
    // URLs are not considered documents. They can only be opened
    // by passing them as arguments.
    Process::Start("IExplore.exe", "www.northwindtraders.com");
    // 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;
    Process::Start(startInfo);
    startInfo->Arguments = "www.northwindtraders.com";
    Process::Start(startInfo);
int main()
    // Get the path that stores favorite links.
    String^ myFavoritesPath = Environment::GetFolderPath(Environment::SpecialFolder::Favorites);
    OpenApplication(myFavoritesPath);
    OpenWithArguments();
    OpenWithStartInfo();
        
         using System;
using System.Diagnostics;
using System.ComponentModel;
namespace MyProcessSample
    class MyProcess
        // Opens the Internet Explorer application.
        void OpenApplication(string myFavoritesPath)
            // Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe");
            // Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath);
        // 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", "www.northwindtraders.com");
            // 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 = new ProcessStartInfo("IExplore.exe");
            startInfo.WindowStyle = ProcessWindowStyle.Minimized;
            Process.Start(startInfo);
            startInfo.Arguments = "www.northwindtraders.com";
            Process.Start(startInfo);
        static void Main()
            // Get the path that stores favorite links.
            string myFavoritesPath =
                Environment.GetFolderPath(Environment.SpecialFolder.Favorites);
            MyProcess myProcess = new MyProcess();
            myProcess.OpenApplication(myFavoritesPath);
            myProcess.OpenWithArguments();
            myProcess.OpenWithStartInfo();
         
          Imports System.Diagnostics
Imports System.ComponentModel
Namespace MyProcessSample
    Class MyProcess
        ' Opens the Internet Explorer application.
        Public Sub OpenApplication(myFavoritesPath As String)
            ' Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe")
            ' Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath)
        End Sub
        ' Opens URLs and .html documents using Internet Explorer.
        Sub OpenWithArguments()
            ' URLs are not considered documents. They can only be opened
            ' by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com")
            ' 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")
        End Sub
        ' Uses the ProcessStartInfo class to start new processes,
        ' both in a minimized mode.
        Sub OpenWithStartInfo()
            Dim startInfo As New ProcessStartInfo("IExplore.exe")
            startInfo.WindowStyle = ProcessWindowStyle.Minimized
            Process.Start(startInfo)
            startInfo.Arguments = "www.northwindtraders.com"
            Process.Start(startInfo)
        End Sub
        Shared Sub Main()
            ' Get the path that stores favorite links.
            Dim myFavoritesPath As String = Environment.GetFolderPath(Environment.SpecialFolder.Favorites)
            Dim myProcess As New MyProcess()
            myProcess.OpenApplication(myFavoritesPath)
            myProcess.OpenWithArguments()
            myProcess.OpenWithStartInfo()
        End Sub
    End Class
End Namespace 'MyProcessSample
          
           Remarks
          
          
           Use this overload to start a process resource by specifying its file name. The overload associates the resource with a new
           
            Process
           
           object.
          
          
           Important
          
          
           Calling this method with untrusted data is a security risk. Call this method only with trusted data. For more information, see
           
            Validate All Inputs
           
           .
          




    

          
           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. The overload is an alternative to the explicit steps of creating a new
           
            Process
           
           instance, setting the
           
            FileName
           
           member of the
           
            StartInfo
           
           property, and calling
           
            Start
           
           for the
           
            Process
           
           instance.
          
          
           You can start a ClickOnce application by setting the
           
            fileName
           
           parameter to 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.
          
          
           Starting a process by specifying its file name is similar to typing the information in the
           
            Run
           
           dialog box of the Windows
           
            Start
           
           menu. Therefore, the file name does not need to represent an executable file. It can be of any file type for which the extension has been associated with an application installed on the system. For example the file name can have a .txt extension if you have associated text files with an editor, such as Notepad, or it can have a .doc if you have associated .doc files with a word processing tool, such as Microsoft Word. Similarly, in the same way that the
           
            Run
           
           dialog box can accept an executable file name with or without the .exe extension, the .exe extension is optional in the
           
            fileName
           
           parameter. For example, you can set the
           
            fileName
           
           parameter to either "Notepad.exe" or "Notepad".
          
          
           This overload does not allow command-line arguments for the process. If you need to specify one or more command-line arguments for the process, use the
           
            Process.Start(ProcessStartInfo)
           
           or
           
            Process.Start(String, String)
           
           overloads.
          
          
           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 and specified start information (including the file name), and you 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 file name of the process resource to start.
          
          
           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 process component's
           
            StartInfo
           
           property, 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.
          
          public:
 static System::Diagnostics::Process ^ Start(System::Diagnostics::ProcessStartInfo ^ startInfo);
          public static System.Diagnostics.Process? Start (System.Diagnostics.ProcessStartInfo startInfo);
          [System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process? Start (System.Diagnostics.ProcessStartInfo startInfo);
          [System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
public static System.Diagnostics.Process? Start (System.Diagnostics.ProcessStartInfo startInfo);
          public static System.Diagnostics.Process Start (System.Diagnostics.ProcessStartInfo startInfo);
          static member Start : System.Diagnostics.ProcessStartInfo -> System.Diagnostics.Process
          [<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : System.Diagnostics.ProcessStartInfo -> System.Diagnostics.Process
          [<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
static member Start : System.Diagnostics.ProcessStartInfo -> System.Diagnostics.Process
          Public Shared Function Start (startInfo As ProcessStartInfo) As Process
          
           Parameters
          
          
           The
           
            ProcessStartInfo
           
           that contains the information that is used to start the process, including the file name and any command-line arguments.
          
          
           Returns
          
          
           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.
          
          
           Attributes
          
          
           UnsupportedOSPlatformAttribute
          
          
           SupportedOSPlatformAttribute
          
          
           InvalidOperationException
          
          
           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
           
           .
          
          
           An error occurred when opening the associated file.
          
          
           The file specified in the
           
            startInfo
           
           parameter's
           
            FileName
           
           property could not be found.
          




    

          
           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."
          
          
           Examples
          
          
           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.
    Process::Start("IExplore.exe");
    // Display the contents of the favorites folder in the browser.
    Process::Start(myFavoritesPath);
// Opens urls and .html documents using Internet Explorer.
void OpenWithArguments()
    // URLs are not considered documents. They can only be opened
    // by passing them as arguments.
    Process::Start("IExplore.exe", "www.northwindtraders.com");
    // 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;
    Process::Start(startInfo);
    startInfo->Arguments = "www.northwindtraders.com";
    Process::Start(startInfo);
int main()
    // Get the path that stores favorite links.
    String^ myFavoritesPath = Environment::GetFolderPath(Environment::SpecialFolder::Favorites);
    OpenApplication(myFavoritesPath);
    OpenWithArguments();
    OpenWithStartInfo();
           
            using System;
using System.Diagnostics;
using System.ComponentModel;
namespace MyProcessSample
    class MyProcess
        // Opens the Internet Explorer application.
        void OpenApplication(string myFavoritesPath)
            // Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe");
            // Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath);
        // 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", "www.northwindtraders.com");
            // 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 = new ProcessStartInfo("IExplore.exe");
            startInfo.WindowStyle = ProcessWindowStyle.Minimized;
            Process.Start(startInfo);
            startInfo.Arguments = "www.northwindtraders.com";
            Process.Start(startInfo);
        static void Main()
            // Get the path that stores favorite links.
            string myFavoritesPath =
                Environment.GetFolderPath(Environment.SpecialFolder.Favorites);
            MyProcess myProcess = new MyProcess();
            myProcess.OpenApplication(myFavoritesPath);
            myProcess.OpenWithArguments();
            myProcess.OpenWithStartInfo();
            
             Imports System.Diagnostics
Imports System.ComponentModel
Namespace MyProcessSample
    Class MyProcess
        ' Opens the Internet Explorer application.
        Public Sub OpenApplication(myFavoritesPath As String)
            ' Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe")
            ' Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath)
        End Sub
        ' Opens URLs and .html documents using Internet Explorer.
        Sub OpenWithArguments()
            ' URLs are not considered documents. They can only be opened
            ' by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com")
            ' 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")
        End Sub
        ' Uses the ProcessStartInfo class to start new processes,
        ' both in a minimized mode.
        Sub OpenWithStartInfo()
            Dim startInfo As New ProcessStartInfo("IExplore.exe")
            startInfo.WindowStyle = ProcessWindowStyle.Minimized
            Process.Start(startInfo)
            startInfo.Arguments = "www.northwindtraders.com"
            Process.Start(startInfo)
        End Sub
        Shared Sub Main()
            ' Get the path that stores favorite links.
            Dim myFavoritesPath As String = Environment.GetFolderPath(Environment.SpecialFolder.Favorites)
            Dim myProcess As New MyProcess()
            myProcess.OpenApplication(myFavoritesPath)
            myProcess.OpenWithArguments()
            myProcess.OpenWithStartInfo()
        End Sub
    End Class
End Namespace 'MyProcessSample
             
              Remarks
             
             
              Use this overload to start a process resource by specifying a
              
               ProcessStartInfo
              
              instance. The overload associates the resource with a new
              
               Process
              
              object.
             
             
              Important
             
             
              Calling this method with untrusted data is a security risk. Call this method only with trusted data. For more information, see
              
               Validate All Inputs
              
              .
             
             
              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 for which the 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 of the
              
               StartInfo
              
              instance 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 and specified start information (including the file name), and you 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.
             




    

             bool Start();
            
            public bool Start ();
            [System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public bool Start ();
            [System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
public bool Start ();
            member this.Start : unit -> bool
            [<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
member this.Start : unit -> bool
            [<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
member this.Start : unit -> bool
            Public Function Start () As Boolean
            
             Returns
            
            
             InvalidOperationException
            
            
             No file name was specified in the
             
              Process
             
             component's
             
              StartInfo
             
             .
            
            
             The
             
              UseShellExecute
             
             member of the
             
              StartInfo
             
             property is
             
              true
             
             while
             
              RedirectStandardInput
             
             ,
             
              RedirectStandardOutput
             
             , or
             
              RedirectStandardError
             
             is
             
              true
             
             .
            
            
             The following example uses an instance of the
             
              Process
             
             class to start a process.
            
            
             #using <System.dll>
using namespace System;
using namespace System::Diagnostics;
using namespace System::ComponentModel;
int main()
    Process^ myProcess = gcnew Process;
        myProcess->StartInfo->UseShellExecute = false;
        // You can start any process, HelloWorld is a do-nothing example.
        myProcess->StartInfo->FileName = "C:\\HelloWorld.exe";
        myProcess->StartInfo->CreateNoWindow = true;
        myProcess->Start();
        // This code assumes the process you are starting will terminate itself. 
        // Given that it is started without a window so you cannot terminate it 
        // on the desktop, it must terminate itself or you can do it programmatically
        // from this application using the Kill method.
    catch ( Exception^ e ) 
        Console::WriteLine( e->Message );
             
              using System;
using System.Diagnostics;
using System.ComponentModel;
namespace MyProcessSample
    class MyProcess
        public static void Main()
                using (Process myProcess = new Process())
                    myProcess.StartInfo.UseShellExecute = false;
                    // You can start any process, HelloWorld is a do-nothing example.
                    myProcess.StartInfo.FileName = "C:\\HelloWorld.exe";
                    myProcess.StartInfo.CreateNoWindow = true;
                    myProcess.Start();
                    // This code assumes the process you are starting will terminate itself.
                    // Given that it is started without a window so you cannot terminate it
                    // on the desktop, it must terminate itself or you can do it programmatically
                    // from this application using the Kill method.
            catch (Exception e)
                Console.WriteLine(e.Message);
              
               Imports System.Diagnostics
Imports System.ComponentModel
Namespace MyProcessSample
    Class MyProcess
        Public Shared Sub Main()
                Using myProcess As New Process()
                    myProcess.StartInfo.UseShellExecute = False
                    ' You can start any process, HelloWorld is a do-nothing example.
                    myProcess.StartInfo.FileName = "C:\\HelloWorld.exe"
                    myProcess.StartInfo.CreateNoWindow = True
                    myProcess.Start()
                    ' This code assumes the process you are starting will terminate itself. 
                    ' Given that it is started without a window so you cannot terminate it 
                    ' on the desktop, it must terminate itself or you can do it programmatically
                    ' from this application using the Kill method.
                End Using
            Catch e As Exception
                Console.WriteLine((e.Message))
            End Try
        End Sub
    End Class
End Namespace
               
                Remarks
               
               
                Use this overload to start a process resource and associate it with the current
                
                 Process
                
                component. 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.
               
               
                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.
               
               
                Important
               
               
                Using an instance of this object with untrusted data is a security risk. Use this object only with trusted data. For more information, see
                
                 Validate All Inputs
                
                .
               
               
                If you are using Visual Studio, this overload of the
                
                 Start
                
                method is the one that you insert into your code after you drag a
                
                 Process
                
                component onto the designer. Use the
                
                 Properties
                
                window to expand the
                
                 StartInfo
                
                category and write the appropriate value into the
                
                 FileName
                
                property. Your changes will appear in the form's
                
                 InitializeComponent
                
                procedure.
               
               
                This overload of
                
                 Start
                
                is not a
                
                 static
                
                method. You must call it from an instance of the
                
                 Process
                
                class. Before calling
                
                 Start
                
                , you must first specify
                
                 StartInfo
                
                property information for this
                
                 Process
                
                instance, because that information is used to determine the process resource to start.
               
               
                The other overloads of the
                
                 Start
                
                method are
                
                 static
                
                members. You do not need to create an instance of the
                
                 Process
                
                component before you call those overloads of the method. Instead, you can call
                
                 Start
                
                for the
                
                 Process
                
                class itself, and a new
                
                 Process
                
                component is created if the process was started. Or,
                
                 null
                
                is returned if a process was reused. The process resource is automatically associated with the new
                
                 Process
                
                component that is returned by the
                
                 Start
                
                method.
               
               
                The
                
                 StartInfo
                
                members can be used to duplicate the functionality of the
                
                 Run
                
                dialog box of the Windows
                
                 Start
                
                menu. Anything that can be typed into a command line can be started by setting the appropriate values in the
                
                 StartInfo
                
                property. The only
                
                 StartInfo
                
                property that must be set is the
                
                 FileName
                
                property. The
                
                 FileName
                
                property does not have to be an executable file. It can be of any file type for which the 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.
               
               
                In the command line, you can specify actions to take for certain types of files. For example, you can print documents or edit text files. Specify these actions using the
                
                 Verb
                
                member of the
                
                 StartInfo
                
                property. For other types of files, you can specify command-line arguments when you start the file from the
                
                 Run
                
                dialog box. For example, you can pass a URL as an argument if you specify your browser as the
                
                 FileName
                
                . These arguments can be specified in the
                
                 StartInfo
                
                property's
                
                 Arguments
                
                member.
               
               
                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 process component's
                
                 StartInfo
                
                property, 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.
               
               public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName, System::Collections::Generic::IEnumerable<System::String ^> ^ arguments);
               public static System.Diagnostics.Process Start (string fileName, System.Collections.Generic.IEnumerable<string> arguments);
               [System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process Start (string fileName, System.Collections.Generic.IEnumerable<string> arguments);
               [System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
public static System.Diagnostics.Process Start (string fileName, System.Collections.Generic.IEnumerable<string> arguments);
               static member Start : string * seq<string> -> System.Diagnostics.Process
               [<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string * seq<string> -> System.Diagnostics.Process
               [<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
static member Start : string * seq<string> -> System.Diagnostics.Process
               Public Shared Function Start (fileName As String, arguments As IEnumerable(Of String)) As Process
               
                Parameters