Process.Start Método

public:
 bool Start();

public bool Start();

member this.Start : unit -> bool

Public Function Start () As Boolean

Devoluções

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

Exceções

Exemplos

O exemplo seguinte utiliza 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

Observações

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

Pode iniciar uma aplicação ClickOnce especificando a localização (por exemplo, um endereço Web) a partir da qual instalou originalmente a aplicação. Não inicie uma aplicação ClickOnce especificando a sua localização instalada no seu disco rígido.

Esta sobrecarga de Start não é um static método. Tens de o chamar a partir de uma instância da Process aula. Antes de chamar Start, deve primeiro especificar StartInfo a informação da propriedade para esta Process ocasião, pois essa informação é usada para determinar o recurso do processo a iniciar.

As outras sobrecargas do Start método são static membros. Não precisa de criar uma instância do Process componente antes de chamar essas sobrecargas do método. Em vez disso, podes pedir Start a Process própria classe, e um novo Process componente é criado se o processo já foi iniciado. Ou, null é devolvido se um processo foi reutilizado. O recurso do processo é automaticamente associado ao novo Process componente que é devolvido pelo Start método.

Os membros StartInfo podem ser usados para duplicar a funcionalidade da caixa de diálogo Run do menu Windows Start. Qualquer coisa que possa ser introduzida numa linha de comandos 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 tem de ser um ficheiro executável. Pode ser de qualquer tipo de ficheiro para o qual a extensão tenha sido associada a uma aplicação instalada no sistema. Por exemplo, a propriedade FileName pode ter uma extensão .txt se tiver ficheiros de texto associados a um editor, como o Notepad, ou pode ter uma extensão .doc se tiver ficheiros .doc associados a uma ferramenta de processamento de texto, como Microsoft Word.

Na linha de comandos, podes especificar ações a tomar para certos tipos de ficheiros. Por exemplo, pode imprimir documentos ou editar ficheiros de texto. Especifique estas ações usando o Verb elemento da StartInfo propriedade. Para outros tipos de ficheiros, podes especificar argumentos de linha de comandos quando inicias o ficheiro a partir da Run caixa de diálogo. Por exemplo, pode passar uma URL como argumento se especificar o seu navegador como o FileName. Estes argumentos podem ser especificados no StartInfo elemento da Arguments propriedade.

Se tiver uma variável de caminho declarada no seu sistema usando aspas, deve 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 no seu caminho, e adicionar usando aspas: path = %path%;"c:\mypath", deve qualificar totalmente qualquer processo c:\mypath ao iniciá-lo.

Sempre que Start começa um processo, pode ser necessário fechá-lo ou arriscar-se a perder recursos do sistema. Fechem processos usando CloseMainWindow ou Kill. Pode verificar se um processo já foi encerrado utilizando a sua HasExited propriedade.

Uma nota sobre os estados de apartamentos nos tópicos geridos é necessária aqui. Quando UseShellExecute estiver true na propriedade do StartInfo componente do processo, certifique-se de que definiu um modelo de threading na sua aplicação, definindo o atributo [STAThread] no main() método. Caso contrário, um thread gerido pode estar num unknown estado ou colocado no MTA estado, sendo este último o que entra em conflito com UseShellExecute ser true. Alguns métodos exigem que o estado do apartamento não seja unknown. Se o estado não estiver explicitamente definido, quando a aplicação encontrar tal método, passa por defeito a MTA, e uma vez definido, o estado do apartamento não pode ser alterado. No entanto, MTA faz com que uma exceção seja lançada quando o shell do sistema operativo está a gerir a thread.

Ver também

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

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

Public Shared Function Start (startInfo As ProcessStartInfo) As Process

Parâmetros

Devoluções

Um novo Process que está associado ao recurso de processo, ou null se nenhum recurso de processo for iniciado. Note que um novo processo que foi iniciado juntamente com instâncias já em execução do mesmo processo será independente dos outros. Além disso, Start pode devolver um Processo não nulo com a sua HasExited propriedade já definida como true. Neste caso, o processo iniciado pode ter ativado uma instância existente de si próprio e depois ter saído.

Exceções

Exemplos

O exemplo seguinte gera primeiro uma instância do Internet Explorer e mostra o conteúdo da pasta Favoritos no navegador. Depois, inicia outras instâncias do Internet Explorer e apresenta algumas páginas ou sites específicos. Finalmente, inicia o Internet Explorer com a janela a ser minimizada enquanto navegas para um site específico.

Para exemplos adicionais de outras utilizações deste 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

Observações

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

Esta sobrecarga permite-lhe iniciar um processo sem antes criar uma nova Process instância. Usar esta sobrecarga com um ProcessStartInfo parâmetro é uma alternativa aos passos explícitos de criar uma nova Process instância, definir as suas StartInfo propriedades e chamar Start a instância Process .

Usar uma ProcessStartInfo instância como parâmetro permite-te chamar Start com o máximo controlo sobre o que é passado para a chamada para iniciar o processo. Se precisar apenas de passar um nome de ficheiro ou um nome de ficheiro e argumentos, não é 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 de representar um ficheiro executável. Pode ser de qualquer tipo de ficheiro para o qual a extensão tenha sido associada a uma aplicação instalada no sistema. Por exemplo, a propriedade FileName pode ter uma extensão .txt se tiver ficheiros de texto associados a um editor, como o Notepad, ou pode ter uma extensão .doc se tiver ficheiros .doc associados a uma ferramenta de processamento de texto, como Microsoft Word.

Pode iniciar uma aplicação ClickOnce especificando a localização (por exemplo, um endereço Web) a partir da qual instalou originalmente a aplicação. Não inicie uma aplicação ClickOnce especificando a sua localização instalada no seu disco rígido.

Se as ProcessStartInfo.UserName propriedades e ProcessStartInfo.Password da StartInfo instância forem definidas, a função não gerida CreateProcessWithLogonW é chamada, que inicia o processo numa nova janela mesmo que o ProcessStartInfo.CreateNoWindow valor da propriedade seja true ou o ProcessStartInfo.WindowStyle valor da propriedade seja ProcessWindowStyle.Hidden. Se a ProcessStartInfo.Domain propriedade for null, a ProcessStartInfo.UserName propriedade deve estar em formato UPN, utilizador@DNS_domain_name.

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 já criou uma Process instância e especificou a informação inicial (incluindo o nome do ficheiro), e quer 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. Tanto esta sobrecarga como a sobrecarga que não tem parâmetros permitem especificar a informação inicial do recurso do processo usando uma ProcessStartInfo instância.

Se tiver uma variável de caminho declarada no seu sistema usando aspas, deve 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 no seu caminho, e adicionar usando aspas: path = %path%;"c:\mypath", deve qualificar totalmente qualquer processo c:\mypath ao iniciá-lo.

Sempre que Start começa um processo, pode ser necessário fechá-lo ou arriscar-se a perder recursos do sistema. Fechem processos usando CloseMainWindow ou Kill. Pode verificar se um processo já foi encerrado utilizando a sua HasExited propriedade.

Uma nota sobre os estados de apartamentos nos tópicos geridos é necessária aqui. Quando UseShellExecute estiver true no startInfo parâmetro, certifique-se de que definiu um modelo de threading na sua aplicação, definindo o atributo [STAThread] no main() método. Caso contrário, um thread gerido pode estar num unknown estado ou colocado no MTA estado, sendo este último o que entra em conflito com UseShellExecute ser true. Alguns métodos exigem que o estado do apartamento não seja unknown. Se o estado não estiver explicitamente definido, quando a aplicação encontrar tal método, passa por defeito a MTA, e uma vez definido, o estado do apartamento não pode ser alterado. No entanto, MTA faz com que uma exceção seja lançada quando o shell do sistema operativo está a gerir a thread.

Ver também

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

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

public static System.Diagnostics.Process Start(string fileName);

static member Start : string -> System.Diagnostics.Process

Public Shared Function Start (fileName As String) As Process

Parâmetros

Devoluções

Um novo Process que está associado ao recurso de processo, ou null se nenhum recurso de processo for iniciado. Note que um novo processo que foi iniciado juntamente com instâncias já em execução do mesmo processo será independente dos outros. Além disso, Start pode devolver um Processo não nulo com a sua HasExited propriedade já definida como true. Neste caso, o processo iniciado pode ter ativado uma instância existente de si próprio e depois ter saído.

Exceções

Exemplos

O exemplo seguinte gera primeiro uma instância do Internet Explorer e mostra o conteúdo da pasta Favoritos no navegador. Depois, inicia outras instâncias do Internet Explorer e apresenta algumas páginas ou sites específicos. Finalmente, inicia o Internet Explorer com a janela a ser minimizada enquanto navegas 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

Observações

Use esta sobrecarga para iniciar um recurso de processo, especificando o seu nome de ficheiro. A sobrecarga associa o recurso a um novo Process objeto.

Esta sobrecarga permite-lhe iniciar um processo sem antes criar uma nova Process instância. A sobrecarga é uma alternativa aos passos explícitos de criar uma nova Process instância, definir o FileName membro da StartInfo propriedade e chamar Start a Process instância.

Pode iniciar uma aplicação ClickOnce definindo o fileName parâmetro para a localização (por exemplo, um endereço Web) a partir da qual instalou originalmente a aplicação. Não inicie uma aplicação ClickOnce especificando a sua localização instalada no seu disco rígido.

Iniciar um processo especificando o nome do ficheiro é semelhante a digitar a informação na caixa de diálogo Run do menu Windows Start. Portanto, o nome do ficheiro não precisa de representar um ficheiro executável. Pode ser de qualquer tipo de ficheiro para o qual a extensão tenha sido associada a uma aplicação instalada no sistema. Por exemplo, o nome do ficheiro pode ter uma extensão de .txt se tiver ficheiros de texto associados a um editor, como o Notepad, ou pode ter uma .doc se tiver ficheiros .doc associados a uma ferramenta de processamento de texto, como Microsoft Word. De forma semelhante, da mesma forma que a Run caixa de diálogo pode aceitar um nome de ficheiro executável com ou sem a extensão .exe, a extensão .exe é opcional no fileName parâmetro. Por exemplo, pode definir o fileName parâmetro para "Notepad.exe" ou "Notepad".

Esta sobrecarga não permite argumentos de linha de comandos para o processo. Se precisares de especificar um ou mais argumentos de linha de comandos para o processo, usa o Process.Start(ProcessStartInfo) or Process.Start(String, String) overloads.

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 já criou uma Process instância e especificou a informação inicial (incluindo o nome do ficheiro), e quer 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. Tanto esta sobrecarga como a sobrecarga sem parâmetros permitem especificar o nome do ficheiro do recurso do processo a iniciar.

Se tiver uma variável de caminho declarada no seu sistema usando aspas, deve 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 no seu caminho, e adicionar usando aspas: path = %path%;"c:\mypath", deve qualificar totalmente qualquer processo c:\mypath ao iniciá-lo.

Sempre que Start começa um processo, pode ser necessário fechá-lo ou arriscar-se a perder recursos do sistema. Fechem processos usando CloseMainWindow ou Kill. Pode verificar se um processo já foi encerrado utilizando a sua HasExited propriedade.

Uma nota sobre os estados de apartamentos nos tópicos geridos é necessária aqui. Quando UseShellExecute estiver true na propriedade do StartInfo componente do processo, certifique-se de que definiu um modelo de threading na sua aplicação, definindo o atributo [STAThread] no main() método. Caso contrário, um thread gerido pode estar num unknown estado ou colocado no MTA estado, sendo este último o que entra em conflito com UseShellExecute ser true. Alguns métodos exigem que o estado do apartamento não seja unknown. Se o estado não estiver explicitamente definido, quando a aplicação encontrar tal método, passa por defeito a MTA, e uma vez definido, o estado do apartamento não pode ser alterado. No entanto, MTA faz com que uma exceção seja lançada quando o shell do sistema operativo está a gerir a thread.

Ver também

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

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

public static System.Diagnostics.Process Start(string fileName, string arguments);

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

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

Parâmetros

Devoluções

Um novo Process que está associado ao recurso de processo, ou null se nenhum recurso de processo for iniciado. Note que um novo processo que foi iniciado juntamente com instâncias já em execução do mesmo processo será independente dos outros. Além disso, Start pode devolver um Processo não nulo com a sua HasExited propriedade já definida como true. Neste caso, o processo iniciado pode ter ativado uma instância existente de si próprio e depois ter saído.

Exceções

Exemplos

O exemplo seguinte gera primeiro uma instância do Internet Explorer e mostra o conteúdo da pasta Favoritos no navegador. Depois, inicia outras instâncias do Internet Explorer e apresenta algumas páginas ou sites específicos. Finalmente, inicia o Internet Explorer com a janela a ser minimizada enquanto navegas 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

Observações

Use esta sobrecarga para iniciar um recurso de processo, especificando o nome do ficheiro e os argumentos da linha de comandos. A sobrecarga associa o recurso a um novo Process objeto.

Esta sobrecarga permite-lhe iniciar um processo sem antes criar uma nova Process instância. A sobrecarga é uma alternativa aos passos explícitos de criar uma nova Process instância, definir os FileName membros e Arguments da StartInfo propriedade e chamar Start a Process instância.

Iniciar um processo especificando o nome do ficheiro e os argumentos é semelhante a digitar o nome do ficheiro e os argumentos da linha de comandos na caixa de diálogo Run do menu Windows Start. Portanto, o nome do ficheiro não precisa de representar um ficheiro executável. Pode ser de qualquer tipo de ficheiro para o qual a extensão tenha sido associada a uma aplicação instalada no sistema. Por exemplo, o nome do ficheiro pode ter uma extensão de .txt se tiver ficheiros de texto associados a um editor, como o Notepad, ou pode ter uma .doc se tiver ficheiros .doc associados a uma ferramenta de processamento de texto, como Microsoft Word. De forma semelhante, da mesma forma que a Run caixa de diálogo pode aceitar um nome de ficheiro executável com ou sem a extensão .exe, a extensão .exe é opcional no fileName parâmetro. Por exemplo, pode definir o fileName parâmetro para "Notepad.exe" ou "Notepad". Se o fileName parâmetro representa um ficheiro executável, o arguments parâmetro pode representar um ficheiro sobre o qual agir, como o ficheiro de texto em Notepad.exe myfile.txt. Se o fileName parâmetro representa um ficheiro de comandos (.cmd), o arguments parâmetro deve incluir um argumento "/c" ou "/k" para especificar se a janela de comandos 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 já criou uma Process instância e especificou a informação inicial (incluindo o nome do ficheiro), e quer 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. Tanto esta sobrecarga como a sobrecarga sem parâmetros permitem especificar o nome do ficheiro do recurso do processo a iniciar e os argumentos da linha de comandos a passar.

Se tiver uma variável de caminho declarada no seu sistema usando aspas, deve 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 no seu caminho, e adicionar usando aspas: path = %path%;"c:\mypath", deve qualificar totalmente qualquer processo c:\mypath ao iniciá-lo.

Sempre que Start começa um processo, pode ser necessário fechá-lo ou arriscar-se a perder recursos do sistema. Fechem processos usando CloseMainWindow ou Kill. Pode verificar se um processo já foi encerrado utilizando a sua HasExited propriedade.

Uma nota sobre os estados de apartamentos nos tópicos geridos é necessária aqui. Quando UseShellExecute estiver true na propriedade do StartInfo componente do processo, certifique-se de que definiu um modelo de threading na sua aplicação, definindo o atributo [STAThread] no main() método. Caso contrário, um thread gerido pode estar num unknown estado ou colocado no MTA estado, sendo este último o que entra em conflito com UseShellExecute ser true. Alguns métodos exigem que o estado do apartamento não seja unknown. Se o estado não estiver explicitamente definido, quando a aplicação encontrar tal método, passa por defeito a MTA, e uma vez definido, o estado do apartamento não pode ser alterado. No entanto, MTA faz com que uma exceção seja lançada quando o shell do sistema operativo está a gerir a thread.

Ver também

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

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

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

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

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

Parâmetros

Devoluções

Um novo Process que está associado ao recurso de processo, ou null se nenhum recurso de processo for iniciado. Note que um novo processo que foi iniciado juntamente com instâncias já em execução do mesmo processo será independente dos outros. Além disso, Start pode devolver um Processo não nulo com a sua HasExited propriedade já definida como true. Neste caso, o processo iniciado pode ter ativado uma instância existente de si próprio e depois ter saído.

Atributos

CLSCompliantAttribute

Exceções

Exemplos

O exemplo de código seguinte mostra o uso desta sobrecarga para iniciar um ficheiro executável e também demonstra o lançamento de um Win32Exception quando se tenta iniciar uma aplicação associada a um ficheiro não executá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

Observações

Use esta sobrecarga para criar um novo processo e o seu thread principal, especificando o nome do ficheiro, nome de utilizador, palavra-passe e domínio. O novo processo executa então o ficheiro executável especificado no contexto de segurança das credenciais especificadas (utilizador, domínio e palavra-passe).

Esta sobrecarga permite-lhe iniciar um processo sem antes criar uma nova Process instância. A sobrecarga é uma alternativa aos passos explícitos de criar uma nova Process instância, definir as FileName, UserName, Password, e Domain propriedades da StartInfo propriedade, e chamar Start a Process instância.

De forma semelhante, da mesma forma que a caixa de diálogo Executar pode aceitar um nome de ficheiro executável com ou sem a extensão .exe, a extensão .exe é opcional no fileName parâmetro. Por exemplo, pode definir o fileName parâmetro para "Notepad.exe" ou "Notepad". Se o fileName parâmetro representa um ficheiro executável, o arguments parâmetro pode representar um ficheiro sobre o qual agir, como o ficheiro de texto em Notepad.exe myfile.txt.

Sempre que Start começa um processo, pode ser necessário fechá-lo ou arriscar-se a perder recursos do sistema. Fechem processos usando CloseMainWindow ou Kill. Pode verificar se um processo já foi encerrado utilizando a sua HasExited propriedade.

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

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

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

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

[<System.CLSCompliant(false)>]
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

Devoluções

Um novo Process que está associado ao recurso de processo, ou null se nenhum recurso de processo for iniciado. Note que um novo processo que foi iniciado juntamente com instâncias já em execução do mesmo processo será independente dos outros. Além disso, Start pode devolver um Processo não nulo com a sua HasExited propriedade já definida como true. Neste caso, o processo iniciado pode ter ativado uma instância existente de si próprio e depois ter saído.

Atributos

CLSCompliantAttribute

Exceções

Observações

Use esta sobrecarga para criar um novo processo e o seu thread principal, especificando o nome do ficheiro, argumentos da linha de comandos, nome de utilizador, palavra-passe e domínio. O novo processo executa então o ficheiro executável especificado no contexto de segurança das credenciais especificadas (utilizador, domínio e palavra-passe).

Esta sobrecarga permite-lhe iniciar um processo sem antes criar uma nova Process instância. A sobrecarga é uma alternativa aos passos explícitos de criar uma nova Process instância, definir as FileNamepropriedades , Arguments, UserName, Password, e Domain da StartInfo propriedade, e chamar Start a Process instância.

De forma semelhante, da mesma forma que a caixa de diálogo Executar pode aceitar um nome de ficheiro executável com ou sem a extensão .exe, a extensão .exe é opcional no fileName parâmetro. Por exemplo, pode definir o fileName parâmetro para "Notepad.exe" ou "Notepad". Se o fileName parâmetro representa um ficheiro executável, o arguments parâmetro pode representar um ficheiro sobre o qual agir, como o ficheiro de texto em Notepad.exe myfile.txt.

Sempre que Start começa um processo, pode ser necessário fechá-lo ou arriscar-se a perder recursos do sistema. Fechem processos usando CloseMainWindow ou Kill. Pode verificar se um processo já foi encerrado utilizando a sua HasExited propriedade.