Process Classe

Definição

Namespace:

System.Diagnostics

Assembly:

System.Diagnostics.Process.dll

Origem:

Process.cs

Fornece acesso a processos locais e remotos e permite que você inicie e pare os processos do sistema local.

public ref class Process : System::ComponentModel::Component, IDisposable

public class Process : System.ComponentModel.Component, IDisposable

type Process = class
    inherit Component
    interface IDisposable

Public Class Process
Inherits Component
Implements IDisposable

Herança

Object

MarshalByRefObject

Component

Process

Implementações

IDisposable

Exemplos

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

#using <System.dll>
using namespace System;
using namespace System::Diagnostics;
using namespace System::ComponentModel;

int main()
{
    Process^ myProcess = gcnew Process;

    try
    {
        myProcess->StartInfo->UseShellExecute = false;
        // You can start any process, HelloWorld is a do-nothing example.
        myProcess->StartInfo->FileName = "C:\\HelloWorld.exe";
        myProcess->StartInfo->CreateNoWindow = true;
        myProcess->Start();
        // This code assumes the process you are starting will terminate itself. 
        // Given that it is started without a window so you cannot terminate it 
        // on the desktop, it must terminate itself or you can do it programmatically
        // from this application using the Kill method.
    }
    catch ( Exception^ e ) 
    {
        Console::WriteLine( e->Message );
    }
}

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

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

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

O exemplo a seguir usa a Process própria classe e um método estático Start para iniciar um processo.

#using <System.dll>

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

// Opens the Internet Explorer application.
void OpenApplication(String^ myFavoritesPath)
{
    // Start Internet Explorer. Defaults to the home page.
    Process::Start("IExplore.exe");

    // Display the contents of the favorites folder in the browser.
    Process::Start(myFavoritesPath);
}

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

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

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

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

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

namespace MyProcessSample
{
    class MyProcess
    {
        // Opens the Internet Explorer application.
        void OpenApplication(string myFavoritesPath)
        {
            // Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe");

            // Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath);
        }

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

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

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

            Process.Start(startInfo);

            startInfo.Arguments = "www.northwindtraders.com";

            Process.Start(startInfo);
        }

        static void Main()
        {
            // Get the path that stores favorite links.
            string myFavoritesPath =
                Environment.GetFolderPath(Environment.SpecialFolder.Favorites);

            MyProcess myProcess = new MyProcess();

            myProcess.OpenApplication(myFavoritesPath);
            myProcess.OpenWithArguments();
            myProcess.OpenWithStartInfo();
        }
    }
}

Imports System.Diagnostics
Imports System.ComponentModel

Namespace MyProcessSample
    Class MyProcess
        ' Opens the Internet Explorer application.
        Public Sub OpenApplication(myFavoritesPath As String)
            ' Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe")

            ' Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath)
        End Sub

        ' Opens URLs and .html documents using Internet Explorer.
        Sub OpenWithArguments()
            ' URLs are not considered documents. They can only be opened
            ' by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com")

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

        ' Uses the ProcessStartInfo class to start new processes,
        ' both in a minimized mode.
        Sub OpenWithStartInfo()
            Dim startInfo As New ProcessStartInfo("IExplore.exe")
            startInfo.WindowStyle = ProcessWindowStyle.Minimized

            Process.Start(startInfo)

            startInfo.Arguments = "www.northwindtraders.com"

            Process.Start(startInfo)
        End Sub

        Shared Sub Main()
            ' Get the path that stores favorite links.
            Dim myFavoritesPath As String = Environment.GetFolderPath(Environment.SpecialFolder.Favorites)

            Dim myProcess As New MyProcess()

            myProcess.OpenApplication(myFavoritesPath)
            myProcess.OpenWithArguments()
            myProcess.OpenWithStartInfo()
        End Sub
    End Class
End Namespace 'MyProcessSample

O exemplo de F# a seguir define uma runProc função que inicia um processo, captura todas as informações de saída e erro e registra o número de milissegundos que o processo executou. A runProc função tem três parâmetros: o nome do aplicativo a ser iniciado, os argumentos a serem fornecidos ao aplicativo e o diretório inicial.

open System
open System.Diagnostics

let runProc filename args startDir : seq<string> * seq<string> = 
    let timer = Stopwatch.StartNew()
    let procStartInfo = 
        ProcessStartInfo(
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
            FileName = filename,
            Arguments = args
        )
    match startDir with | Some d -> procStartInfo.WorkingDirectory <- d | _ -> ()

    let outputs = System.Collections.Generic.List<string>()
    let errors = System.Collections.Generic.List<string>()
    let outputHandler f (_sender:obj) (args:DataReceivedEventArgs) = f args.Data
    use p = new Process(StartInfo = procStartInfo)
    p.OutputDataReceived.AddHandler(DataReceivedEventHandler (outputHandler outputs.Add))
    p.ErrorDataReceived.AddHandler(DataReceivedEventHandler (outputHandler errors.Add))
    let started = 
        try
            p.Start()
        with | ex ->
            ex.Data.Add("filename", filename)
            reraise()
    if not started then
        failwithf "Failed to start process %s" filename
    printfn "Started %s with pid %i" p.ProcessName p.Id
    p.BeginOutputReadLine()
    p.BeginErrorReadLine()
    p.WaitForExit()
    timer.Stop()
    printfn "Finished %s after %A milliseconds" filename timer.ElapsedMilliseconds
    let cleanOut l = l |> Seq.filter (fun o -> String.IsNullOrEmpty o |> not)
    cleanOut outputs,cleanOut errors

O código para a runProc função foi escrito por ImaginaryDevelopment e está disponível na Licença Pública da Microsoft.

Comentários

Um Process componente fornece acesso a um processo em execução em um computador. Um processo, nos termos mais simples, é um aplicativo em execução. Um thread é a unidade básica para a qual o sistema operacional aloca o tempo do processador. Um thread pode executar qualquer parte do código do processo, incluindo partes que estão sendo executadas por outro thread.

O Process componente é uma ferramenta útil para iniciar, parar, controlar e monitorar aplicativos. Você pode usar o Process componente para obter uma lista dos processos em execução ou iniciar um novo processo. Um Process componente é usado para acessar processos do sistema. Depois que um Process componente for inicializado, ele poderá ser usado para obter informações sobre o processo em execução. Essas informações incluem o conjunto de threads, os módulos carregados (.dll e arquivos .exe) e informações de desempenho, como a quantidade de memória que o processo está usando.

Esse tipo implementa a interface IDisposable. Quando você terminar de usar o tipo, deverá descartá-lo direta ou indiretamente. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/finally. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic). Para obter mais informações, consulte a seção "Usando um objeto que implementa idisposable" na documentação da IDisposable interface.

Importante

Chamar métodos desta classe quando você tiver dados não confiáveis é um risco à segurança. Chame os métodos dessa classe somente quando você tiver dados confiáveis. Para obter mais informações, consulte Validar todas as entradas.

Observação

Processos de 32 bits não podem acessar os módulos de um processo de 64 bits. Se você tentar obter informações sobre um processo de 64 bits de um processo de 32 bits, receberá uma Win32Exception exceção. Um processo de 64 bits, por outro lado, pode acessar os módulos de um processo de 32 bits.

O componente de processo obtém informações sobre um grupo de propriedades de uma só vez. Depois que o Process componente tiver obtido informações sobre um membro de qualquer grupo, ele armazenará em cache os valores das outras propriedades nesse grupo e não obterá novas informações sobre os outros membros do grupo até que você chame o Refresh método . Portanto, não há garantia de que um valor de propriedade seja mais recente do que a última chamada para o Refresh método . Os detalhamentos de grupo são dependentes do sistema operacional.

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ê deverá qualificar totalmente qualquer processo no c:\mypath ao iniciá-lo.

Um processo do sistema é identificado exclusivamente no sistema por seu identificador de processo. Como muitos recursos do Windows, um processo também é identificado por seu identificador, que pode não ser exclusivo no computador. Um identificador é o termo genérico para um identificador de um recurso. O sistema operacional persiste o identificador de processo, que é acessado por meio da Handle propriedade do Process componente, mesmo quando o processo é encerrado. Assim, você pode obter as informações administrativas do processo, como o ExitCode (geralmente zero para êxito ou um código de erro diferente de zero) e o ExitTime. Identificadores são um recurso extremamente valioso, portanto, o vazamento de identificadores é mais virulento do que a perda de memória.

Observação

Esta classe contém uma demanda de link e uma demanda de herança no nível de classe que se aplica a todos os membros. Um SecurityException é lançado quando o chamador imediato ou a classe derivada não tem permissão de confiança total. Para obter detalhes sobre as demandas de segurança, consulte Vincular demandas.

Notas do .NET Core

Em .NET Framework, a Process classe, por padrão, usa Console codificações, que normalmente são codificações de página de código, para os fluxos de entrada, saída e erro. Por exemplo, em sistemas cuja cultura é inglês (Estados Unidos), a página de código 437 é a codificação padrão para a Console classe . No entanto, o .NET Core pode disponibilizar apenas um subconjunto limitado dessas codificações. Se esse for o caso, ele usará Encoding.UTF8 como a codificação padrão.

Se um Process objeto depender de codificações de página de código específicas, você ainda poderá disponibilizá-las fazendo o seguinte antes de chamar qualquer Process método:

1. Recupere o EncodingProvider objeto da CodePagesEncodingProvider.Instance propriedade .

2. Passe o EncodingProvider objeto para o Encoding.RegisterProvider método para disponibilizar as codificações adicionais compatíveis com o provedor de codificação.

Em Process seguida, a classe usará automaticamente a codificação padrão do sistema em vez de UTF8, desde que você tenha registrado o provedor de codificação antes de chamar qualquer Process método.

Construtores

Process()

Inicializa uma nova instância da classe Process.

Propriedades

BasePriority	Obtém a prioridade base do processo associado.
CanRaiseEvents	Obtém um valor que indica se o componente pode acionar um evento. (Herdado de Component)
Container	Obtém o IContainer que contém o Component. (Herdado de Component)
DesignMode	Obtém um valor que indica se o Component está no modo de design no momento. (Herdado de Component)
EnableRaisingEvents	Obtém ou define se o evento Exited deve ser gerado quando o processo é encerrado.
Events	Obtém a lista de manipuladores de eventos que estão anexados a este Component. (Herdado de Component)
ExitCode	Obtém o valor especificado pelo processo associado quando ele foi finalizado.
ExitTime	Obtém a hora em que o processo associado foi encerrado.
Handle	Obtém o identificador nativo do processo associado.
HandleCount	Obtém o número de identificadores abertos pelo processo.
HasExited	Obtém um valor que indica se o processo associado foi encerrado.
Id	Obtém o identificador exclusivo para o processo associado.
MachineName	Obtém o nome do computador no qual o processo associado está em execução.
MainModule	Obtém o módulo principal do processo associado.
MainWindowHandle	Obtém o identificador de janela da janela principal do processo associado.
MainWindowTitle	Obtém a legenda da janela principal do processo.
MaxWorkingSet	Obtém ou define o tamanho de conjunto de trabalho máximo permitido em bytes para o processo associado.
MinWorkingSet	Obtém ou define o tamanho de conjunto de trabalho mínimo permitido em bytes para o processo associado.
Modules	Obtém os módulos que foram carregados pelo processo associado.
NonpagedSystemMemorySize	Obsoleto. Obtém a quantidade de memória não paginada, em bytes, alocada para o processo associado.
NonpagedSystemMemorySize64	Obtém a quantidade de memória não paginada, em bytes, alocada para o processo associado.
PagedMemorySize	Obsoleto. Obtém a quantidade de memória paginada, em bytes, alocada para o processo associado.
PagedMemorySize64	Obtém a quantidade de memória paginada, em bytes, alocada para o processo associado.
PagedSystemMemorySize	Obsoleto. Obtém a quantidade de memória paginável do sistema, em bytes, alocada para o processo associado.
PagedSystemMemorySize64	Obtém a quantidade de memória paginável do sistema, em bytes, alocada para o processo associado.
PeakPagedMemorySize	Obsoleto. Obtém a quantidade máxima de memória, em bytes, no arquivo de paginação de memória virtual usado pelo processo associado.
PeakPagedMemorySize64	Obtém a quantidade máxima de memória, em bytes, no arquivo de paginação de memória virtual usado pelo processo associado.
PeakVirtualMemorySize	Obsoleto. Obtém a quantidade máxima de memória virtual, em bytes, usada pelo processo associado.
PeakVirtualMemorySize64	Obtém a quantidade máxima de memória virtual, em bytes, usada pelo processo associado.
PeakWorkingSet	Obsoleto. Obtém o tamanho do conjunto de trabalho máximo para o processo associado, em bytes.
PeakWorkingSet64	Obtém a quantidade máxima de memória física, em bytes, usada pelo processo associado.
PriorityBoostEnabled	Obtém ou define um valor que indica se a prioridade do processo associada deve temporariamente ser aumentada pelo sistema operacional quando o foco estiver na janela principal.
PriorityClass	Obtém ou define a categoria geral de prioridade para o processo associado.
PrivateMemorySize	Obsoleto. Obtém a quantidade de memória privada, em bytes, alocada ao processo associado.
PrivateMemorySize64	Obtém a quantidade de memória privada, em bytes, alocada ao processo associado.
PrivilegedProcessorTime	Obtém o tempo de processador privilegiado para esse processo.
ProcessName	Obtém o nome do processo.
ProcessorAffinity	Obtém ou define os processadores nos quais os threads desse processo podem ser agendados para execução.
Responding	Obtém um valor que indica se a interface do usuário do processo está respondendo.
SafeHandle	Obtém o identificador nativo para esse processo.
SessionId	Obtém o identificador de sessão dos Serviços de Terminal para o processo associado.
Site	Obtém ou define o ISite do Component. (Herdado de Component)
StandardError	Obtém um fluxo usado para ler a saída de erro do aplicativo.
StandardInput	Obtém um fluxo usado para gravar a entrada do aplicativo.
StandardOutput	Obtém um fluxo usado para ler a saída textual do aplicativo.
StartInfo	Obtém ou define as propriedades a serem passadas para o método Start() do Process.
StartTime	Obtém a hora em que o processo associado foi iniciado.
SynchronizingObject	Obtém ou define o objeto usado para realizar marshaling das chamadas do manipulador de eventos emitidas como resultado de um evento de encerramento de um processo.
Threads	Obtém o conjunto de threads que estão em execução no processo associado.
TotalProcessorTime	Obtém o tempo de processador total para esse processo.
UserProcessorTime	Obtém o tempo de processador do usuário para esse processo.
VirtualMemorySize	Obsoleto. Obtém o tamanho da memória virtual do processo, em bytes.
VirtualMemorySize64	Obtém a quantidade de memória virtual, em bytes, alocada para o processo associado.
WorkingSet	Obsoleto. Obtém o uso de memória física do processo associado, em bytes.
WorkingSet64	Obtém a quantidade de memória física, em bytes, alocada para o processo associado.

Métodos

BeginErrorReadLine()	Inicia as operações de leitura assíncronas no fluxo StandardError redirecionado do aplicativo.
BeginOutputReadLine()	Inicia as operações de leitura assíncronas no fluxo StandardOutput redirecionado do aplicativo.
CancelErrorRead()	Cancela a operação de leitura assíncrona no fluxo StandardError redirecionado de um aplicativo.
CancelOutputRead()	Cancela a operação de leitura assíncrona no fluxo StandardOutput redirecionado de um aplicativo.
Close()	Libera todos os recursos associados a esse componente.
CloseMainWindow()	Fecha um processo que tem uma interface do usuário enviando uma mensagem de fechamento à janela principal.
CreateObjRef(Type)	Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto. (Herdado de MarshalByRefObject)
Dispose()	Libera todos os recursos usados pelo Component. (Herdado de Component)
Dispose(Boolean)	Libere todos os recursos usados por esse processo.
EnterDebugMode()	Coloca um componente Process no estado para interagir com os processos do sistema operacional executados em um modo especial, habilitando a propriedade nativa SeDebugPrivilege no thread atual.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetCurrentProcess()	Obtém um novo componente Process e o associa ao processo ativo no momento.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLifetimeService()	Obsoleto. Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância. (Herdado de MarshalByRefObject)
GetProcessById(Int32)	Retorna um novo componente Process, tendo em conta o identificador de um processo no computador local.
GetProcessById(Int32, String)	Retorna um novo componente Process, dado um identificador de processo e o nome de um computador na rede.
GetProcesses()	Cria um novo componente Process para cada recurso de processo no computador local.
GetProcesses(String)	Cria um novo componente Process para cada recurso de processo no computador especificado.
GetProcessesByName(String)	Cria uma matriz de novos componentes Process e os associa a todos os recursos do processo no computador local que compartilham o nome do processo especificado.
GetProcessesByName(String, String)	Cria uma matriz de novos componentes Process e os associa a todos os recursos do processo em um computador remoto que compartilham o nome do processo especificado.
GetService(Type)	Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container. (Herdado de Component)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
InitializeLifetimeService()	Obsoleto. Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância. (Herdado de MarshalByRefObject)
Kill()	Interrompe imediatamente o processo associado.
Kill(Boolean)	Interrompe imediatamente o processo associado e, opcionalmente, seus processos filho/descendentes.
LeaveDebugMode()	Tira um componente Process do estado que permite a ele interagir com processos do sistema operacional que são executados em um modo especial.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
MemberwiseClone(Boolean)	Cria uma cópia superficial do objeto MarshalByRefObject atual. (Herdado de MarshalByRefObject)
OnExited()	Aciona o evento Exited.
Refresh()	Descarta informações sobre o processo associado que foi armazenado em cache dentro do componente do processo.
Start()	Inicia (ou reutiliza) o recurso do processo que é especificado pela propriedade StartInfo desse componente Process e o associa ao 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 componente Process.
Start(String)	Inicia um recurso de processo especificando o nome de um arquivo de aplicativo ou documento e associa o recurso a um novo componente Process.
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)	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 componente Process.
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 componente Process.
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 componente Process.
ToString()	Formata o nome do processo como uma cadeia de caracteres, combinada com o tipo de componente pai, se aplicável.
WaitForExit()	Instrui o componente Process a esperar indefinidamente que o processo associado seja encerrado.
WaitForExit(Int32)	Instrui o componente Process a aguardar o número especificado de milissegundos para que o processo associado seja encerrado.
WaitForExit(TimeSpan)	Instrui o componente Processo a aguardar a quantidade de tempo especificada para que o processo associado seja encerrado.
WaitForExitAsync(CancellationToken)	Instrui o componente do processo a aguardar a saída do processo associado ou o cancelamento do cancellationToken.
WaitForInputIdle()	Faz com que o componente Process aguarde por tempo indefinido até que o processo associado entre em um estado ocioso. Essa sobrecarga se aplica apenas a processos com uma interface do usuário e, portanto, um loop de mensagem.
WaitForInputIdle(Int32)	Faz com que o componente Process a aguarde o número especificado de milissegundos para que o processo entre em um estado ocioso. Essa sobrecarga se aplica apenas a processos com uma interface do usuário e, portanto, um loop de mensagem.
WaitForInputIdle(TimeSpan)	Faz com que o Process componente aguarde o especificado timeout para que o processo associado entre em um estado ocioso. Essa sobrecarga se aplica apenas a processos com uma interface do usuário e, portanto, um loop de mensagem.

Eventos

Disposed	Ocorre quando o componente é disposto por uma chamada ao método Dispose(). (Herdado de Component)
ErrorDataReceived	Ocorre quando um aplicativo realiza gravação em seu fluxo StandardError redirecionado.
Exited	Ocorre quando um processo é fechado.
OutputDataReceived	Ocorre sempre que um aplicativo grava uma linha no fluxo StandardOutput redirecionado.

Confira também

• Start()
• ProcessStartInfo
• CloseMainWindow()
• Kill()
• ProcessThread