Process.Start Método

Definição

Namespace:

System.Diagnostics

Assemblies:

netstandard.dll, System.Diagnostics.Process.dll

Inicia um recurso de processo e o associa a um Process componente.

Sobrecargas

Nome	Description
Start(String, String, String, SecureString, String)	Inicia um recurso de processo especificando o nome de um aplicativo, um conjunto de argumentos de linha de comando, um nome de usuário, uma senha e um domínio e associa o recurso a um novo Process componente.
Start(String, String, SecureString, String)	Inicia um recurso de processo especificando o nome de um aplicativo, um nome de usuário, uma senha e um domínio e associa o recurso a um novo Process componente.
Start(String, String)	Inicia um recurso de processo especificando o nome de um aplicativo e um conjunto de argumentos de linha de comando e associa o recurso a um novo Process componente.
Start(String)	Inicia um recurso de processo especificando o nome de um documento ou arquivo de aplicativo e associa o recurso a um novo Process componente.
Start(ProcessStartInfo)	Inicia o recurso de processo especificado pelo parâmetro que contém informações de início do processo (por exemplo, o nome do arquivo do processo a ser iniciado) e associa o recurso a um novo Process componente.
Start()	Inicia (ou reutiliza) o recurso de processo especificado pela StartInfo propriedade desse Process componente e o associa ao componente.
Start(String, IEnumerable<String>)	Inicia um recurso de processo especificando o nome de um aplicativo e um conjunto de argumentos de linha de comando.

Start(String, String, String, SecureString, String)

Origem:

Process.Unix.cs

Importante

Esta API não está em conformidade com CLS.

Inicia um recurso de processo especificando o nome de um aplicativo, um conjunto de argumentos de linha de comando, um nome de usuário, uma senha e um domínio e associa o recurso a um novo Process componente.

public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName, System::String ^ arguments, 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 arguments, string userName, System.Security.SecureString password, string domain);

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

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

Parâmetros

fileName

String

O nome de um arquivo de aplicativo a ser executado no processo.

arguments

String

Argumentos de linha de comando a serem passados ao iniciar o processo.

userName

String

O nome de usuário a ser usado ao iniciar o processo.

password

SecureString

Um SecureString que contém a senha a ser usada ao iniciar o processo.

domain

String

O domínio a ser usado ao iniciar o processo.

Retornos

Process

Uma nova Process associada ao recurso de processo ou null se nenhum recurso de processo for iniciado. Observe que um novo processo iniciado juntamente com instâncias já em execução do mesmo processo será independente dos outros. Além disso, o Start pode retornar um processo não nulo com sua HasExited propriedade já definida como true. Nesse caso, o processo iniciado pode ter ativado uma instância existente de si mesmo e, em seguida, encerrado.

Atributos

CLSCompliantAttribute SupportedOSPlatformAttribute

Exceções

InvalidOperationException

Nenhum nome de arquivo foi especificado.

Win32Exception

Erro ao abrir o arquivo associado.

- ou -

O arquivo especificado no fileName não foi encontrado.

- ou -

A soma do comprimento dos argumentos e o comprimento do caminho completo para o arquivo associado excede 2080. A mensagem de erro associada a essa exceção pode ser uma das seguintes: "A área de dados passada para uma chamada do sistema é muito pequena" ou "O acesso é negado".

ObjectDisposedException

O objeto de processo já foi descartado.

PlatformNotSupportedException

Não há suporte para esse membro no Linux ou no macOS (somente no .NET Core).

Comentários

Use essa sobrecarga para criar um novo processo e seu thread primário especificando seu nome de arquivo, argumentos de linha de comando, nome de usuário, senha e domínio. Em seguida, o novo processo executa o arquivo executável especificado no contexto de segurança das credenciais especificadas (usuário, domínio e senha).

Importante

Chamar esse método com dados não confiáveis é um risco à segurança. Chame esse método apenas com dados confiáveis. Para obter mais informações, consulte Validar Todas as Entradas.

Observação

Quando o arquivo executável está localizado em uma unidade remota, você deve identificar o compartilhamento de rede usando um URI (uniform resource identifier), não uma letra de unidade vinculada.

Observação

Se o endereço do arquivo executável a ser iniciado for uma URL, o processo não será iniciado e null será retornado.

Essa sobrecarga permite que você inicie um processo sem primeiro criar uma nova Process instância. A sobrecarga é uma alternativa às etapas explícitas de criação de uma nova Process instância, definindo as UserNamePasswordArgumentsFileNamepropriedades e propriedades da StartInfo propriedade e Domain chamando Start a Process instância.

Da mesma forma, da mesma forma que a caixa de diálogo Executar pode aceitar um nome de arquivo executável com ou sem a extensão .exe, a extensão .exe é opcional no fileName parâmetro. Por exemplo, você pode definir o fileName parâmetro como "Notepad.exe" ou "Bloco de notas". Se o fileName parâmetro representar um arquivo executável, o arguments parâmetro poderá representar um arquivo para agir, como o arquivo de texto em Notepad.exe myfile.txt.

Observação

O nome do arquivo deve representar um arquivo executável nas Start sobrecargas que têm userName, passworde domain parâmetros.

Sempre que você usar Start para iniciar um processo, talvez seja necessário fechá-lo ou correr o risco de perder recursos do sistema. Fechar processos usando CloseMainWindow ou Kill. Você pode verificar se um processo já foi fechado usando sua HasExited propriedade.

Start(String, String, SecureString, String)

Origem:

Process.Unix.cs

Importante

Esta API não está em conformidade com CLS.

Inicia um recurso de processo especificando o nome de um aplicativo, um nome de usuário, uma senha e um domínio e associa o recurso a um novo Process componente.

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)>]
[<System.Runtime.Versioning.SupportedOSPlatform("windows")>]
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

Parâmetros

fileName

String

O nome de um arquivo de aplicativo a ser executado no processo.

userName

String

O nome de usuário a ser usado ao iniciar o processo.

password

SecureString

Um SecureString que contém a senha a ser usada ao iniciar o processo.

domain

String

O domínio a ser usado ao iniciar o processo.

Retornos

Process

Uma nova Process associada ao recurso de processo ou null se nenhum recurso de processo for iniciado. Observe que um novo processo iniciado juntamente com instâncias já em execução do mesmo processo será independente dos outros. Além disso, o Start pode retornar um processo não nulo com sua HasExited propriedade já definida como true. Nesse caso, o processo iniciado pode ter ativado uma instância existente de si mesmo e, em seguida, encerrado.

Atributos

CLSCompliantAttribute SupportedOSPlatformAttribute

Exceções

InvalidOperationException

Nenhum nome de arquivo foi especificado.

Win32Exception

Erro ao abrir o arquivo associado.

- ou -

O arquivo especificado no fileName não foi encontrado.

ObjectDisposedException

O objeto de processo já foi descartado.

PlatformNotSupportedException

Não há suporte para esse membro no Linux ou no macOS (somente no .NET Core).

Exemplos

O exemplo de código a seguir mostra o uso dessa sobrecarga para iniciar um arquivo executável e também demonstra o lançamento de um Win32Exception quando é feita uma tentativa de iniciar um aplicativo associado a um arquivo não reexecutável.

// 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;
        do
        {
            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();

        try
        {
            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) + "\\";

        try
        {
            // 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);
        }

        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("\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();
        }
    }
}

// NOTE: This example requires a text.txt file file in your Documents folder
open System
open System.Diagnostics
open System.Security
open System.ComponentModel

printf "Enter your domain: "
let domain = stdin.ReadLine()
printf "Enter you user name: "
let uname = stdin.ReadLine()
printf "Enter your password: "
let password = new SecureString()

let mutable key = Console.ReadKey(true)

while key.Key <> ConsoleKey.Enter do
    // Ignore any key out of range.
    if int key.Key >= 33 && int key.Key <= 90 && key.Key <> ConsoleKey.Enter then
        // Append the character to the password.
        password.AppendChar key.KeyChar
        Console.Write "*"

    key <- Console.ReadKey(true)

printfn ""

try
    printfn "\nTrying to launch NotePad using your login information..."
    Process.Start("notepad.exe", uname, password, domain) |> ignore
with :? Win32Exception as ex ->
    printfn $"{ex.Message}"

let path = Environment.GetFolderPath Environment.SpecialFolder.MyDocuments + @"\"

try
    // The following call to Start succeeds if test.txt exists.
    printfn "\nTrying to launch 'text.txt'..."
    Process.Start $"{path}text.txt" |> ignore
with :? Win32Exception as ex ->
    printfn $"{ex.Message}"

try
    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.
        printfn "\nTrying to launch 'text.txt' with your login information..."
        Process.Start($"{path}text.txt", uname, password, domain) |> ignore
    with :? Win32Exception as ex ->
        printfn $"{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
        Do
            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()

        Try
            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) + "\"

        Try
            ' 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

        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

Comentários

Use essa sobrecarga para criar um novo processo e seu thread primário especificando seu nome de arquivo, nome de usuário, senha e domínio. Em seguida, o novo processo executa o arquivo executável especificado no contexto de segurança das credenciais especificadas (usuário, domínio e senha).

Importante

Chamar esse método com dados não confiáveis é um risco à segurança. Chame esse método apenas com dados confiáveis. Para obter mais informações, consulte Validar Todas as Entradas.

Observação

Quando o arquivo executável está localizado em uma unidade remota, você deve identificar o compartilhamento de rede usando um URI (uniform resource identifier), não uma letra de unidade vinculada.

Observação

Se o endereço do arquivo executável a ser iniciado for uma URL, o processo não será iniciado e null será retornado.

Essa sobrecarga permite que você inicie um processo sem primeiro criar uma nova Process instância. A sobrecarga é uma alternativa às etapas explícitas de criação de uma nova Process instância, definindo as PasswordFileNameUserNameDomain propriedades e propriedades StartInfo da propriedade e chamando Start a Process instância.

Da mesma forma, da mesma forma que a caixa de diálogo Executar pode aceitar um nome de arquivo executável com ou sem a extensão .exe, a extensão .exe é opcional no fileName parâmetro. Por exemplo, você pode definir o fileName parâmetro como "Notepad.exe" ou "Bloco de notas". Se o fileName parâmetro representar um arquivo executável, o arguments parâmetro poderá representar um arquivo para agir, como o arquivo de texto em Notepad.exe myfile.txt.

Observação

O nome do arquivo deve representar um arquivo executável nas Start sobrecargas que têm userName, passworde domain parâmetros.

Sempre que você usar Start para iniciar um processo, talvez seja necessário fechá-lo ou correr o risco de perder recursos do sistema. Fechar processos usando CloseMainWindow ou Kill. Você pode verificar se um processo já foi fechado usando sua HasExited propriedade.

Start(String, String)

Origem:

Process.cs

Inicia um recurso de processo especificando o nome de um aplicativo e um conjunto de argumentos de linha de comando e associa o recurso a um novo Process componente.

public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName, System::String ^ arguments);

[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process Start(string fileName, string arguments);

[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string * string -> System.Diagnostics.Process

Public Shared Function Start (fileName As String, arguments As String) As Process

Parâmetros

fileName

String

O nome de um arquivo de aplicativo a ser executado no processo.

arguments

String

Argumentos de linha de comando a serem passados ao iniciar o processo.

Retornos

Process

Uma nova Process associada ao recurso de processo ou null se nenhum recurso de processo for iniciado. Observe que um novo processo iniciado juntamente com instâncias já em execução do mesmo processo será independente dos outros. Além disso, o Start pode retornar um processo não nulo com sua HasExited propriedade já definida como true. Nesse caso, o processo iniciado pode ter ativado uma instância existente de si mesmo e, em seguida, encerrado.

Atributos

SupportedOSPlatformAttribute UnsupportedOSPlatformAttribute

Exceções

InvalidOperationException

O fileName parâmetro ou arguments o parâmetro é null.

Win32Exception

Erro ao abrir o arquivo associado.

- ou -

O arquivo especificado no fileName não foi encontrado.

- ou -

A soma do comprimento dos argumentos e o comprimento do caminho completo para o processo excede 2080. A mensagem de erro associada a essa exceção pode ser uma das seguintes: "A área de dados passada para uma chamada do sistema é muito pequena" ou "O acesso é negado".

ObjectDisposedException

O objeto de processo já foi descartado.

FileNotFoundException

A variável de ambiente PATH tem uma cadeia de caracteres contendo aspas.

Exemplos

O exemplo a seguir primeiro gera uma instância do Internet Explorer e exibe o conteúdo da pasta Favoritos no navegador. Em seguida, ele inicia algumas outras instâncias do Internet Explorer e exibe algumas páginas ou sites específicos. Por fim, ele inicia o Internet Explorer com a janela sendo minimizada enquanto navega para um site específico.

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();
        }
    }
}

module processstartstatic

open System
open System.Diagnostics

// Opens the Internet Explorer application.
let openApplication (myFavoritesPath: string) =
    // Start Internet Explorer. Defaults to the home page.
    Process.Start "IExplore.exe" |> ignore

    // Display the contents of the favorites folder in the browser.
    Process.Start myFavoritesPath |> ignore

// Opens urls and .html documents using Internet Explorer.
let openWithArguments () =
    // url's are not considered documents. They can only be opened
    // by passing them as arguments.
    Process.Start("IExplore.exe", "www.northwindtraders.com") |> ignore

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

// Uses the ProcessStartInfo class to start new processes,
// both in a minimized mode.
let openWithStartInfo () =
    let startInfo = ProcessStartInfo "IExplore.exe"
    startInfo.WindowStyle <- ProcessWindowStyle.Minimized

    Process.Start startInfo |> ignore

    startInfo.Arguments <- "www.northwindtraders.com"

    Process.Start startInfo |> ignore

// Get the path that stores favorite links.
let myFavoritesPath = Environment.GetFolderPath Environment.SpecialFolder.Favorites

openApplication myFavoritesPath
openWithArguments ()
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

Comentários

Use essa sobrecarga para iniciar um recurso de processo especificando seu nome de arquivo e argumentos de linha de comando. A sobrecarga associa o recurso a um novo Process objeto.

Importante

Chamar esse método com dados não confiáveis é um risco à segurança. Chame esse método apenas com dados confiáveis. Para obter mais informações, consulte Validar Todas as Entradas.

Observação

Se o endereço do arquivo executável a ser iniciado for uma URL, o processo não será iniciado e null será retornado.

Essa sobrecarga permite que você inicie um processo sem primeiro criar uma nova Process instância. A sobrecarga é uma alternativa às etapas explícitas de criação de uma nova Process instância, definição de ArgumentsFileName membros e membros da StartInfo propriedade e chamada Start para a Process instância.

Iniciar um processo especificando seu nome de arquivo e argumentos é semelhante a digitar o nome do arquivo e argumentos de linha de comando na Run caixa de diálogo do menu do Windows Start . Portanto, o nome do arquivo não precisa representar um arquivo executável. Pode ser de qualquer tipo de arquivo para o qual a extensão foi associada a um aplicativo instalado no sistema. Por exemplo, o nome do arquivo pode ter uma extensão de .txt se você tiver arquivos de texto associados a um editor, como o Bloco de Notas, ou pode ter um .doc se você tiver associado arquivos .doc a uma ferramenta de processamento de palavras, como o Microsoft Word. Da mesma forma, da mesma forma que a Run caixa de diálogo pode aceitar um nome de arquivo executável com ou sem a extensão .exe, a extensão .exe é opcional no fileName parâmetro. Por exemplo, você pode definir o fileName parâmetro como "Notepad.exe" ou "Bloco de notas". Se o fileName parâmetro representar um arquivo executável, o arguments parâmetro poderá representar um arquivo para agir, como o arquivo de texto em Notepad.exe myfile.txt. Se o fileName parâmetro representar um arquivo de comando (.cmd), o arguments parâmetro deverá incluir um argumento "/c" ou "/k" para especificar se a janela de comando sai ou permanece após a conclusão.

Ao contrário das outras sobrecargas, a sobrecarga de Start que não tem parâmetros não é um static membro. Use essa sobrecarga quando você já criou uma Process instância e especificou informações de início (incluindo o nome do arquivo) e deseja iniciar um recurso de processo e associá-lo à instância existente Process . Use uma das static sobrecargas quando quiser criar um novo Process componente em vez de iniciar um processo para um componente existente. Essa sobrecarga e a sobrecarga que não tem parâmetros permitem que você especifique o nome do arquivo do recurso de processo a ser iniciado e os argumentos de linha de comando a serem passados.

Se você tiver uma variável de caminho declarada em seu sistema usando aspas, deverá qualificar totalmente esse caminho ao iniciar qualquer processo encontrado nesse local. Caso contrário, o sistema não encontrará o caminho. Por exemplo, se c:\mypath não estiver em seu caminho e você adicioná-lo usando aspas: path = %path%;"c:\mypath", você deve qualificar totalmente qualquer processo ao c:\mypath iniciá-lo.

Observação

ASP.NET página da Web e o código de controle do servidor são executados no contexto do processo de trabalho ASP.NET no servidor Web. Se você usar o Start método em uma página da Web ASP.NET ou controle de servidor, o novo processo será executado no servidor Web com permissões restritas. O processo não é iniciado no mesmo contexto que o navegador do cliente e não tem acesso à área de trabalho do usuário.

Sempre que você usar Start para iniciar um processo, talvez seja necessário fechá-lo ou correr o risco de perder recursos do sistema. Fechar processos usando CloseMainWindow ou Kill. Você pode verificar se um processo já foi fechado usando sua HasExited propriedade.

Uma anotação sobre estados de apartamento em threads gerenciados é necessária aqui. Quando UseShellExecute estiver true na propriedade do componente do StartInfo processo, verifique se você definiu um modelo de threading em seu aplicativo definindo o atributo [STAThread] no main() método. Caso contrário, um thread gerenciado pode estar em um unknown estado ou ser colocado no estado, o último dos quais entra em MTA conflito com UseShellExecute ser true. Alguns métodos exigem que o estado do apartamento não seja unknown. Se o estado não estiver definido explicitamente, quando o aplicativo encontrar esse método, ele usará como padrão MTAe, uma vez definido, o estado do apartamento não poderá ser alterado. No entanto, MTA faz com que uma exceção seja gerada quando o shell do sistema operacional estiver gerenciando o thread.

Confira também

• FileName
• StartInfo
• ProcessStartInfo
• CloseMainWindow()
• Kill()

Start(String)

Origem:

Process.cs

Inicia um recurso de processo especificando o nome de um documento ou arquivo de aplicativo e associa o recurso a um novo Process componente.

public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName);

[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process Start(string fileName);

[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string -> System.Diagnostics.Process

Public Shared Function Start (fileName As String) As Process

Parâmetros

fileName

String

O nome de um documento ou arquivo de aplicativo a ser executado no processo.

Retornos

Process

Uma nova Process associada ao recurso de processo ou null se nenhum recurso de processo for iniciado. Observe que um novo processo iniciado juntamente com instâncias já em execução do mesmo processo será independente dos outros. Além disso, o Start pode retornar um processo não nulo com sua HasExited propriedade já definida como true. Nesse caso, o processo iniciado pode ter ativado uma instância existente de si mesmo e, em seguida, encerrado.

Atributos

SupportedOSPlatformAttribute UnsupportedOSPlatformAttribute

Exceções

Win32Exception

Erro ao abrir o arquivo associado.

- ou -

O arquivo especificado no fileName não foi encontrado.

ObjectDisposedException

O objeto de processo já foi descartado.

FileNotFoundException

A variável de ambiente PATH tem uma cadeia de caracteres contendo aspas.

Exemplos

O exemplo a seguir primeiro gera uma instância do Internet Explorer e exibe o conteúdo da pasta Favoritos no navegador. Em seguida, ele inicia algumas outras instâncias do Internet Explorer e exibe algumas páginas ou sites específicos. Por fim, ele inicia o Internet Explorer com a janela sendo minimizada enquanto navega para um site específico.

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();
        }
    }
}

module processstartstatic

open System
open System.Diagnostics

// Opens the Internet Explorer application.
let openApplication (myFavoritesPath: string) =
    // Start Internet Explorer. Defaults to the home page.
    Process.Start "IExplore.exe" |> ignore

    // Display the contents of the favorites folder in the browser.
    Process.Start myFavoritesPath |> ignore

// Opens urls and .html documents using Internet Explorer.
let openWithArguments () =
    // url's are not considered documents. They can only be opened
    // by passing them as arguments.
    Process.Start("IExplore.exe", "www.northwindtraders.com") |> ignore

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

// Uses the ProcessStartInfo class to start new processes,
// both in a minimized mode.
let openWithStartInfo () =
    let startInfo = ProcessStartInfo "IExplore.exe"
    startInfo.WindowStyle <- ProcessWindowStyle.Minimized

    Process.Start startInfo |> ignore

    startInfo.Arguments <- "www.northwindtraders.com"

    Process.Start startInfo |> ignore

// Get the path that stores favorite links.
let myFavoritesPath = Environment.GetFolderPath Environment.SpecialFolder.Favorites

openApplication myFavoritesPath
openWithArguments ()
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

Comentários

Use essa sobrecarga para iniciar um recurso de processo especificando seu nome de arquivo. A sobrecarga associa o recurso a um novo Process objeto.

Importante

Chamar esse método com dados não confiáveis é um risco à segurança. Chame esse método apenas com dados confiáveis. Para obter mais informações, consulte Validar Todas as Entradas.

Observação

Se o endereço do arquivo executável a ser iniciado for uma URL, o processo não será iniciado e null será retornado.

Essa sobrecarga permite que você inicie um processo sem primeiro criar uma nova Process instância. A sobrecarga é uma alternativa às etapas explícitas de criação de uma nova Process instância, definição do FileName membro da StartInfo propriedade e chamada Start para a Process instância.

Você pode iniciar um aplicativo ClickOnce definindo o fileName parâmetro para o local (por exemplo, um endereço Web) do qual você instalou originalmente o aplicativo. Não inicie um aplicativo ClickOnce especificando seu local instalado no disco rígido.

Iniciar um processo especificando seu nome de arquivo é semelhante a digitar as informações na Run caixa de diálogo do menu do Windows Start . Portanto, o nome do arquivo não precisa representar um arquivo executável. Pode ser de qualquer tipo de arquivo para o qual a extensão foi associada a um aplicativo instalado no sistema. Por exemplo, o nome do arquivo pode ter uma extensão de .txt se você tiver arquivos de texto associados a um editor, como o Bloco de Notas, ou pode ter um .doc se você tiver associado arquivos .doc a uma ferramenta de processamento de palavras, como o Microsoft Word. Da mesma forma, da mesma forma que a Run caixa de diálogo pode aceitar um nome de arquivo executável com ou sem a extensão .exe, a extensão .exe é opcional no fileName parâmetro. Por exemplo, você pode definir o fileName parâmetro como "Notepad.exe" ou "Bloco de notas".

Essa sobrecarga não permite argumentos de linha de comando para o processo. Se você precisar especificar um ou mais argumentos de linha de comando para o processo, use as sobrecargas ou Process.Start(String, String) as Process.Start(ProcessStartInfo) sobrecargas.

Ao contrário das outras sobrecargas, a sobrecarga de Start que não tem parâmetros não é um static membro. Use essa sobrecarga quando você já criou uma Process instância e especificou informações de início (incluindo o nome do arquivo) e deseja iniciar um recurso de processo e associá-lo à instância existente Process . Use uma das static sobrecargas quando quiser criar um novo Process componente em vez de iniciar um processo para um componente existente. Essa sobrecarga e a sobrecarga que não tem parâmetros permitem que você especifique o nome do arquivo do recurso de processo a ser iniciado.

Se você tiver uma variável de caminho declarada em seu sistema usando aspas, deverá qualificar totalmente esse caminho ao iniciar qualquer processo encontrado nesse local. Caso contrário, o sistema não encontrará o caminho. Por exemplo, se c:\mypath não estiver em seu caminho e você adicioná-lo usando aspas: path = %path%;"c:\mypath", você deve qualificar totalmente qualquer processo ao c:\mypath iniciá-lo.

Observação

ASP.NET página da Web e o código de controle do servidor são executados no contexto do processo de trabalho ASP.NET no servidor Web. Se você usar o Start método em uma página da Web ASP.NET ou controle de servidor, o novo processo será executado no servidor Web com permissões restritas. O processo não é iniciado no mesmo contexto que o navegador do cliente e não tem acesso à área de trabalho do usuário.

Sempre que você usar Start para iniciar um processo, talvez seja necessário fechá-lo ou correr o risco de perder recursos do sistema. Fechar processos usando CloseMainWindow ou Kill. Você pode verificar se um processo já foi fechado usando sua HasExited propriedade.

Uma anotação sobre estados de apartamento em threads gerenciados é necessária aqui. Quando UseShellExecute estiver true na propriedade do componente do StartInfo processo, verifique se você definiu um modelo de threading em seu aplicativo definindo o atributo [STAThread] no main() método. Caso contrário, um thread gerenciado pode estar em um unknown estado ou ser colocado no estado, o último dos quais entra em MTA conflito com UseShellExecute ser true. Alguns métodos exigem que o estado do apartamento não seja unknown. Se o estado não estiver definido explicitamente, quando o aplicativo encontrar esse método, ele usará como padrão MTAe, uma vez definido, o estado do apartamento não poderá ser alterado. No entanto, MTA faz com que uma exceção seja gerada quando o shell do sistema operacional estiver gerenciando o thread.

Confira também

• FileName
• StartInfo
• CloseMainWindow()
• Kill()

Start(ProcessStartInfo)

Origem:

Process.cs

Inicia o recurso de processo especificado pelo parâmetro que contém informações de início do processo (por exemplo, o nome do arquivo do processo a ser iniciado) e associa o recurso a um novo Process componente.

public:
 static System::Diagnostics::Process ^ Start(System::Diagnostics::ProcessStartInfo ^ startInfo);

[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process? Start(System.Diagnostics.ProcessStartInfo startInfo);

[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : System.Diagnostics.ProcessStartInfo -> System.Diagnostics.Process

Public Shared Function Start (startInfo As ProcessStartInfo) As Process

Parâmetros

startInfo

ProcessStartInfo

O ProcessStartInfo que contém as informações usadas para iniciar o processo, incluindo o nome do arquivo e quaisquer argumentos de linha de comando.

Retornos

Process

Uma nova Process associada ao recurso de processo ou null se nenhum recurso de processo for iniciado. Observe que um novo processo iniciado juntamente com instâncias já em execução do mesmo processo será independente dos outros. Além disso, o Start pode retornar um processo não nulo com sua HasExited propriedade já definida como true. Nesse caso, o processo iniciado pode ter ativado uma instância existente de si mesmo e, em seguida, encerrado.

Atributos

SupportedOSPlatformAttribute UnsupportedOSPlatformAttribute

Exceções

InvalidOperationException

Nenhum nome de arquivo foi especificado na startInfo propriedade do FileName parâmetro.

- ou -

A UseShellExecute propriedade do startInfo parâmetro é true e a RedirectStandardInputpropriedade , RedirectStandardOutputou RedirectStandardError também trueé .

- ou -

A UseShellExecute propriedade do startInfo parâmetro é true e a UserName propriedade não null está ou está vazia ou a Password propriedade não nullé .

ArgumentNullException

O startInfo parâmetro é null.

ObjectDisposedException

O objeto de processo já foi descartado.

Win32Exception

Erro ao abrir o arquivo associado.

- ou -

Não foi possível encontrar o startInfo arquivo especificado na propriedade do FileName parâmetro.

- ou -

A soma do comprimento dos argumentos e o comprimento do caminho completo para o processo excede 2080. A mensagem de erro associada a essa exceção pode ser uma das seguintes: "A área de dados passada para uma chamada do sistema é muito pequena" ou "O acesso é negado".

PlatformNotSupportedException

Método sem suporte em sistemas operacionais sem suporte para shell, como Nano Server (somente.NET Core).

Exemplos

O exemplo a seguir primeiro gera uma instância do Internet Explorer e exibe o conteúdo da pasta Favoritos no navegador. Em seguida, ele inicia algumas outras instâncias do Internet Explorer e exibe algumas páginas ou sites específicos. Por fim, ele inicia o Internet Explorer com a janela sendo minimizada enquanto navega para um site específico.

Para obter exemplos adicionais de outros usos desse método, consulte as propriedades individuais da ProcessStartInfo classe.

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();
        }
    }
}

module processstartstatic

open System
open System.Diagnostics

// Opens the Internet Explorer application.
let openApplication (myFavoritesPath: string) =
    // Start Internet Explorer. Defaults to the home page.
    Process.Start "IExplore.exe" |> ignore

    // Display the contents of the favorites folder in the browser.
    Process.Start myFavoritesPath |> ignore

// Opens urls and .html documents using Internet Explorer.
let openWithArguments () =
    // url's are not considered documents. They can only be opened
    // by passing them as arguments.
    Process.Start("IExplore.exe", "www.northwindtraders.com") |> ignore

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

// Uses the ProcessStartInfo class to start new processes,
// both in a minimized mode.
let openWithStartInfo () =
    let startInfo = ProcessStartInfo "IExplore.exe"
    startInfo.WindowStyle <- ProcessWindowStyle.Minimized

    Process.Start startInfo |> ignore

    startInfo.Arguments <- "www.northwindtraders.com"

    Process.Start startInfo |> ignore

// Get the path that stores favorite links.
let myFavoritesPath = Environment.GetFolderPath Environment.SpecialFolder.Favorites

openApplication myFavoritesPath
openWithArguments ()
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

Comentários

Use essa sobrecarga para iniciar um recurso de processo especificando uma ProcessStartInfo instância. A sobrecarga associa o recurso a um novo Process objeto.

Importante

Chamar esse método com dados não confiáveis é um risco à segurança. Chame esse método apenas com dados confiáveis. Para obter mais informações, consulte Validar Todas as Entradas.

Observação

Se o endereço do arquivo executável a ser iniciado for uma URL, o processo não será iniciado e null será retornado.

Essa sobrecarga permite que você inicie um processo sem primeiro criar uma nova Process instância. Usar essa sobrecarga com um ProcessStartInfo parâmetro é uma alternativa às etapas explícitas de criar uma nova Process instância, definir suas StartInfo propriedades e chamar Start a Process instância.

Usar uma ProcessStartInfo instância como parâmetro permite que você chame Start com mais controle sobre o que é passado para a chamada para iniciar o processo. Se você precisar passar apenas um nome de arquivo ou um nome de arquivo e argumentos, não será necessário criar uma nova ProcessStartInfo instância, embora essa seja uma opção. A única Process.StartInfo propriedade que deve ser definida é a FileName propriedade. A FileName propriedade não precisa representar um arquivo executável. Pode ser de qualquer tipo de arquivo para o qual a extensão foi associada a um aplicativo instalado no sistema. Por exemplo, a FileName propriedade pode ter uma extensão de .txt se você tiver arquivos de texto associados a um editor, como o Bloco de Notas, ou pode ter uma extensão .doc se você tiver associado arquivos .doc a uma ferramenta de processamento de palavras, como o Microsoft Word.

Você pode iniciar um aplicativo ClickOnce especificando o local (por exemplo, um endereço Web) do qual você instalou originalmente o aplicativo. Não inicie um aplicativo ClickOnce especificando seu local instalado no disco rígido.

Se as propriedades e as ProcessStartInfo.UserName propriedades da instância forem definidas, a função não gerenciada CreateProcessWithLogonW será chamada, o que iniciará o processo em uma nova janela, mesmo que o valor da ProcessStartInfo.CreateNoWindow propriedade seja true ou o valor da ProcessStartInfo.WindowStyle propriedade seja ProcessWindowStyle.Hidden.StartInfoProcessStartInfo.Password Se a ProcessStartInfo.Domain propriedade estivernull, a ProcessStartInfo.UserName propriedade deverá estar no formato UPN,DNS_domain_name de usuário@.

Ao contrário das outras sobrecargas, a sobrecarga de Start que não tem parâmetros não é um static membro. Use essa sobrecarga quando você já criou uma Process instância e especificou informações de início (incluindo o nome do arquivo) e deseja iniciar um recurso de processo e associá-lo à instância existente Process . Use uma das static sobrecargas quando quiser criar um novo Process componente em vez de iniciar um processo para um componente existente. Essa sobrecarga e a sobrecarga que não tem parâmetros permitem que você especifique as informações de início do recurso de processo usando uma ProcessStartInfo instância.

Se você tiver uma variável de caminho declarada em seu sistema usando aspas, deverá qualificar totalmente esse caminho ao iniciar qualquer processo encontrado nesse local. Caso contrário, o sistema não encontrará o caminho. Por exemplo, se c:\mypath não estiver em seu caminho e você adicioná-lo usando aspas: path = %path%;"c:\mypath", você deve qualificar totalmente qualquer processo ao c:\mypath iniciá-lo.

Observação

ASP.NET página da Web e o código de controle do servidor são executados no contexto do processo de trabalho ASP.NET no servidor Web. Se você usar o Start método em uma página da Web ASP.NET ou controle de servidor, o novo processo será executado no servidor Web com permissões restritas. O processo não é iniciado no mesmo contexto que o navegador do cliente e não tem acesso à área de trabalho do usuário.

Sempre que você usar Start para iniciar um processo, talvez seja necessário fechá-lo ou correr o risco de perder recursos do sistema. Fechar processos usando CloseMainWindow ou Kill. Você pode verificar se um processo já foi fechado usando sua HasExited propriedade.

Uma anotação sobre estados de apartamento em threads gerenciados é necessária aqui. Quando UseShellExecute estiver true no startInfo parâmetro, verifique se você definiu um modelo de threading em seu aplicativo definindo o atributo [STAThread] no main() método. Caso contrário, um thread gerenciado pode estar em um unknown estado ou ser colocado no estado, o último dos quais entra em MTA conflito com UseShellExecute ser true. Alguns métodos exigem que o estado do apartamento não seja unknown. Se o estado não estiver definido explicitamente, quando o aplicativo encontrar esse método, ele usará como padrão MTAe, uma vez definido, o estado do apartamento não poderá ser alterado. No entanto, MTA faz com que uma exceção seja gerada quando o shell do sistema operacional estiver gerenciando o thread.

Confira também

• StartInfo
• FileName
• ProcessStartInfo
• CloseMainWindow()
• Kill()

Start()

Origem:

Process.cs

Inicia (ou reutiliza) o recurso de processo especificado pela StartInfo propriedade desse Process componente e o associa ao componente.

public:
 bool Start();

[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public bool Start();

[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
member this.Start : unit -> bool

Public Function Start () As Boolean

Retornos

Boolean

true se um recurso de processo for iniciado; false se nenhum novo recurso de processo for iniciado (por exemplo, se um processo existente for reutilizado).

Atributos

SupportedOSPlatformAttribute UnsupportedOSPlatformAttribute

Exceções

InvalidOperationException

Nenhum nome de arquivo foi especificado no Process componente.StartInfo

- ou -

O UseShellExecute membro da StartInfo propriedade é true while RedirectStandardInput, RedirectStandardOutputou RedirectStandardError is true.

Win32Exception

Erro ao abrir o arquivo associado.

ObjectDisposedException

O objeto de processo já foi descartado.

PlatformNotSupportedException

Método sem suporte em sistemas operacionais sem suporte para shell, como Nano Server (somente.NET Core).

Exemplos

O exemplo a seguir usa uma instância da Process classe para iniciar um processo.

using System;
using System.Diagnostics;
using System.ComponentModel;

namespace MyProcessSample
{
    class MyProcess
    {
        public static void Main()
        {
            try
            {
                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);
            }
        }
    }
}

open System.Diagnostics

try
    use 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() |> ignore
// 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.
with e ->
    printfn $"{e.Message}"

Imports System.Diagnostics
Imports System.ComponentModel

Namespace MyProcessSample
    Class MyProcess
        Public Shared Sub Main()
            Try
                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

Comentários

Use essa sobrecarga para iniciar um recurso de processo e associá-lo ao componente atual Process . O valor true retornado indica que um novo recurso de processo foi iniciado. Se o recurso de processo especificado pelo FileName membro da StartInfo propriedade já estiver em execução no computador, nenhum recurso de processo adicional será iniciado. Em vez disso, o recurso de processo em execução é reutilizado e false retornado.

Você pode iniciar um aplicativo ClickOnce especificando o local (por exemplo, um endereço Web) do qual você instalou originalmente o aplicativo. Não inicie um aplicativo ClickOnce especificando seu local instalado no disco rígido.

Importante

Usar uma instância desse tipo com dados não confiáveis é um risco à segurança. Use esse objeto somente com dados confiáveis. Para obter mais informações, consulte Validar Todas as Entradas.

Observação

Se você estiver usando o Visual Studio, essa sobrecarga do Start método é a que você insere em seu código depois de arrastar um Process componente para o designer. Use a Properties janela para expandir a StartInfo categoria e gravar o valor apropriado na FileName propriedade. As alterações serão exibidas no procedimento do InitializeComponent formulário.

Essa sobrecarga não Start é um static método. Você deve chamá-lo de uma instância da Process classe. Antes de chamar Start, primeiro você deve especificar StartInfo informações de propriedade para essa Process instância, pois essas informações são usadas para determinar o recurso de processo a ser iniciado.

As outras sobrecargas do Start método são static membros. Você não precisa criar uma instância do Process componente antes de chamar essas sobrecargas do método. Em vez disso, você pode chamar Start a Process própria classe e um novo Process componente será criado se o processo tiver sido iniciado. Ou será null retornado se um processo tiver sido reutilizado. O recurso de processo é automaticamente associado ao novo Process componente retornado pelo Start método.

Os StartInfo membros podem ser usados para duplicar a funcionalidade da caixa de Run diálogo do menu do Windows Start . Qualquer coisa que possa ser digitada em uma linha de comando pode ser iniciada definindo os valores apropriados na StartInfo propriedade. A única StartInfo propriedade que deve ser definida é a FileName propriedade. A FileName propriedade não precisa ser um arquivo executável. Pode ser de qualquer tipo de arquivo para o qual a extensão foi associada a um aplicativo instalado no sistema. Por exemplo, a FileName propriedade pode ter uma extensão de .txt se você tiver arquivos de texto associados a um editor, como o Bloco de Notas, ou pode ter uma extensão .doc se você tiver associado arquivos .doc a uma ferramenta de processamento de palavras, como o Microsoft Word.

Na linha de comando, você pode especificar ações a serem tomadas para determinados tipos de arquivos. Por exemplo, você pode imprimir documentos ou editar arquivos de texto. Especifique essas ações usando o Verb membro da StartInfo propriedade. Para outros tipos de arquivos, você pode especificar argumentos de linha de comando ao iniciar o arquivo na Run caixa de diálogo. Por exemplo, você pode passar uma URL como um argumento se especificar seu navegador como o FileName. Esses argumentos podem ser especificados no StartInfo membro da Arguments propriedade.

Se você tiver uma variável de caminho declarada em seu sistema usando aspas, deverá qualificar totalmente esse caminho ao iniciar qualquer processo encontrado nesse local. Caso contrário, o sistema não encontrará o caminho. Por exemplo, se c:\mypath não estiver em seu caminho e você adicioná-lo usando aspas: path = %path%;"c:\mypath", você deve qualificar totalmente qualquer processo ao c:\mypath iniciá-lo.

Observação

ASP.NET página da Web e o código de controle do servidor são executados no contexto do processo de trabalho ASP.NET no servidor Web. Se você usar o Start método em uma página da Web ASP.NET ou controle de servidor, o novo processo será executado no servidor Web com permissões restritas. O processo não é iniciado no mesmo contexto que o navegador do cliente e não tem acesso à área de trabalho do usuário.

Sempre que você usar Start para iniciar um processo, talvez seja necessário fechá-lo ou correr o risco de perder recursos do sistema. Fechar processos usando CloseMainWindow ou Kill. Você pode verificar se um processo já foi fechado usando sua HasExited propriedade.

Uma anotação sobre estados de apartamento em threads gerenciados é necessária aqui. Quando UseShellExecute estiver true na propriedade do componente do StartInfo processo, verifique se você definiu um modelo de threading em seu aplicativo definindo o atributo [STAThread] no main() método. Caso contrário, um thread gerenciado pode estar em um unknown estado ou ser colocado no estado, o último dos quais entra em MTA conflito com UseShellExecute ser true. Alguns métodos exigem que o estado do apartamento não seja unknown. Se o estado não estiver definido explicitamente, quando o aplicativo encontrar esse método, ele usará como padrão MTAe, uma vez definido, o estado do apartamento não poderá ser alterado. No entanto, MTA faz com que uma exceção seja gerada quando o shell do sistema operacional estiver gerenciando o thread.

Confira também

• StartInfo
• FileName
• ProcessStartInfo
• CloseMainWindow()
• Kill()

Start(String, IEnumerable<String>)

Origem:

Process.cs

Inicia um recurso de processo especificando o nome de um aplicativo e um conjunto de argumentos de linha de comando.

public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName, System::Collections::Generic::IEnumerable<System::String ^> ^ arguments);

[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
[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.SupportedOSPlatform("maccatalyst")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string * seq<string> -> System.Diagnostics.Process

Public Shared Function Start (fileName As String, arguments As IEnumerable(Of String)) As Process

Parâmetros

fileName

String

O nome de um documento ou arquivo de aplicativo a ser executado no processo.

arguments

IEnumerable<String>

Os argumentos de linha de comando a serem passados ao iniciar o processo.

Retornos

Process

Uma nova Process associada ao recurso de processo ou null se nenhum recurso de processo for iniciado.

Atributos

SupportedOSPlatformAttribute UnsupportedOSPlatformAttribute

Comentários

Cada argumento será escapado automaticamente, se necessário.

Importante

Chamar esse método com dados não confiáveis é um risco à segurança. Chame esse método apenas com dados confiáveis. Para obter mais informações, consulte Validar Todas as Entradas.