Msdn process waitforexit

Msdn process waitforexit
Eu quero esperar por um processo para concluir, mas process. WaitForExit () trava minha GUI. Existe uma maneira baseada em eventos, ou eu preciso gerar um thread para bloquear até sair e delegar o evento eu mesmo?
A partir do 4.0 / C # 5, é melhor representá-lo usando o padrão assíncrono.
Se você escolher a resposta @MgSam, esteja ciente, se você passar por WaitForExitAsync algum CancellationToken, que será automaticamente cancelado após o atraso especificado, você poderá obter uma InvalidOperationException. Para corrigir isso, você precisa mudar.

Processo . Método WaitForExit (Int32)
A documentação de referência da API tem uma nova casa. Visite o Navegador da API em docs. microsoft para ver a nova experiência.
Instrui o componente Processo a aguardar o número especificado de milissegundos para o processo associado sair.
Assembly: System (no System. dll)
Parâmetros
O período de tempo, em milissegundos, para aguardar a saída do processo associado. O máximo é o maior valor possível de um inteiro de 32 bits, que representa infinito para o sistema operacional.
Valor de retorno.
true se o processo associado tiver saído; Caso contrário, false.
A configuração de espera não pôde ser acessada.
Nenhuma identificação de processo foi definida e uma Handle da qual a propriedade Id pode ser determinada não existe.
Não há processo associado a este objeto Process.
Você está tentando chamar WaitForExit (Int32) para um processo que está sendo executado em um computador remoto. Este método está disponível apenas para processos em execução no computador local.
WaitForExit (Int32) faz com que o segmento atual espere até que o processo associado termine. Deve ser chamado depois que todos os outros métodos forem chamados no processo. Para evitar o bloqueio do segmento atual, use o evento Exited.
Este método instrui o componente Process a aguardar uma quantidade finita de tempo para o processo sair. Se o processo associado não sair no final do intervalo porque a solicitação para finalizar é negada, false é retornado para o procedimento de chamada. Você pode especificar um número negativo (Infinito) por milissegundos e Processo. WaitForExit (Int32) se comportará da mesma maneira que a sobrecarga WaitForExit (). Se você passar 0 (zero) para o método, ele retornará true somente se o processo já tiver saído; caso contrário, retorna imediatamente false.
No Framework 3.5 e em versões anteriores, se milissegundos fosse -1, a sobrecarga WaitForExit (Int32) aguardava milissegundos MaxValue (aproximadamente 24 dias), não indefinidamente.
Quando a saída padrão foi redirecionada para manipuladores de eventos assíncronos, é possível que o processamento de saída não seja concluído quando esse método retornar. Para garantir que o tratamento assíncrono de eventos tenha sido concluído, chame a sobrecarga WaitForExit () que não recebe nenhum parâmetro após receber um valor verdadeiro dessa sobrecarga. Para ajudar a garantir que o evento Exited seja tratado corretamente nos aplicativos do Windows Forms, defina a propriedade SynchronizingObject.
Quando um processo associado sai (é desligado pelo sistema operacional por meio de uma finalização normal ou anormal), o sistema armazena informações administrativas sobre o processo e retorna ao componente que chamou WaitForExit (Int32). O componente de processo pode acessar as informações, que inclui o ExitTime, usando o identificador para o processo de saída.
Como o processo associado foi encerrado, a propriedade Handle do componente não aponta mais para um recurso de processo existente. Em vez disso, o identificador pode ser usado apenas para acessar as informações do sistema operacional sobre o recurso do processo. O sistema está ciente de identificadores para processos que não foram liberados pelos componentes do processo, portanto, ele mantém as informações de ExitTime e identificador na memória até que o componente de processo especificamente libera os recursos. Por esse motivo, sempre que você chamar a instância Start for Process, chame Close quando o processo associado tiver terminado e você não precisar mais de nenhuma informação administrativa sobre ele. Close libera a memória alocada para o processo finalizado.

Gerenciando Processos no PowerShell.
Várias pessoas perguntaram recentemente sobre como gerenciar processos no PowerShell. Esta postagem do blog deve responder a várias dessas perguntas.
Como se poderia esperar do & # 8220; shell & # 8221; Como parte do PowerShell, você não precisa fazer nada especial para iniciar um processo. Em uma linguagem de programação como o VBScript, você precisa fazer algo bastante complexo como:
Defina objWMIService = GetObject (& # 8220; winmgmts: & # 8221; _.
Defina objStartup = objWMIService. Get (& # 8220; Win32_ProcessStartup & # 8221;)
Defina objConfig = objStartup. SpawnInstance_.
Defina objProcess = GetObject (& # 8220; winmgmts: raiz \ cimv2: Win32_Process & # 8221;)
objProcess. Create & # 8220; Notepad. exe & # 8221 ;, Null, objConfig, intProcessID.
mas em shells (PowerShell, cmd. exe, bash, etc.) você pode simplesmente iniciar um programa como o bloco de notas simplesmente digitando & # 8220; notepad & # 8221; como mostrado.
Agora você notará que, quando fizer isso, o shell retornará imediatamente e solicitará o próximo comando. Isso porque o notepad é um processo de GUI do win32 e é executado em segundo plano. Por outro lado, se você iniciar um aplicativo de console como o & # 8220; ping. exe & # 8221 ;, o PowerShell esperará até que esse processo seja concluído.
Mas e se eu quiser esperar pelo processo do Win32? No cmd. exe, você faria isso com & # 8220; start / wait & # 8221; mas esse comando não está (diretamente) disponível no PowerShell. Então, o que fazemos?
O PowerShell executa diretamente executáveis. Se aguarda a saída do processo, o código de saída será deixado em $ LASTEXITCODE. Agora, se um executável do Win32 for o último comando em um pipeline e não for redirecionado, o processo será executado em segundo plano. No entanto, se você enviar sua saída para algo, o PowerShell aguardará a saída do comando.
Portanto, essa é uma espera simples (se não intuitiva) para aguardar a saída de um processo da GUI.
Como alternativa, se o processo já estiver em execução, você poderá usar Get-Process para recuperar as informações necessárias e, em seguida, executar um WaitForExit () nesse objeto.
Aqui está um exemplo um pouco mais sofisticado, onde abrimos um documento em vez de iniciar um processo. Dessa vez, encontraremos o processo pelo título da janela, e não pelo nome do executável.
Infelizmente, procurar um processo sempre significa que você pode encontrar o processo errado. Idealmente, você gostaria de obter o objeto Process diretamente. Portanto, para um gerenciamento de processos mais preciso, você terá que usar a classe System. Diagnostics. Process e iniciar os processos por conta própria. Por exemplo, você pode usar [diagnostics. process] :: Start () para aguardar um processo:
Observe o uso de & # 8220; $ pwd \ foo. txt & # 8221; para especificar o caminho completo para o arquivo. Isso ocorre porque o PowerShell mantém sua própria ideia do diretório atual. (Esta nota se aplica ao uso de qualquer API que acesse o sistema de arquivos - você precisa dar um caminho absoluto.)
Agora, estamos começando a voltar ao nível de complexidade que você encontra em uma linguagem de programação. No entanto, você também tem todo o poder dessas linguagens. Aqui está um script de exemplo & # 8220; background. ps1 & # 8221; Isso permitirá que você execute um scriptblock desanexado em uma janela separada (ou na mesma janela se você especificar o parâmetro – inconsole.
Este script permite que você faça coisas no PowerShell que você não pode fazer a partir do cmd. exe, mas pode fazer a partir do VBScript.
Finalmente, aqui estão mais duas maneiras de trabalhar com processos. Mesmo que o PowerShell não tenha um comando de início, o cmd. exe faz isso, você pode iniciar / esperar fazendo.
E, por último, mas não menos importante, o PowerShell Community Extensions inclui um cmdlet Start-Process. Você pode obter uma lista desses recursos em:
Bruce Payette [MSFT]
Windows PowerShell Tech Lead.
Top Server & # 038; Blogs de ferramentas.
Postagens recentes.
DSC Resource Kit versão de fevereiro de 2018 7 de fevereiro de 2018 Configuração do estado desejado (DSC) Planning Update & # 8211; Janeiro de 2018 26 de janeiro de 2018 PowerShell Core 6.1 Roadmap 24 de janeiro de 2018 PowerShell Core 6.0: disponível em geral (GA) e com suporte! 10 de janeiro de 2018.
Eu tenho um script master powershell chamando um subscrito. O subscrito lança um erro, mas $ LASTEXITCODE em MASTER não parece pegá-lo.
Basicamente meu processo pára no momento em que o comando throw é executado e o processo não é retornado para o MASTER.
Existe uma maneira de contornar isso?
Muito obrigado por este artigo !
Seria muito bom ver uma versão atualizada disso com todas as extensões V2 como Start-Process e as extensões Jobs.
Obrigado por todo o trabalho duro, o PowerShell está se preparando para ser uma ferramenta realmente incrível para automação de processos!
Você pode encontrar mais detalhes aqui: [link] Shay [link]
Uma breve pesquisa no google: & amp; lt; [link] & gt; onde é dada a ponta a saída do pipe para out-null. bloco de anotações.
Na verdade eu estou integrando o VB e um programa escrito em C ++. Eu sou capaz de executar este programa C ++, clicando em um botão projetado em VB. Quando clico no botão, o prgram é executado na plataforma DOS. Eu não quero essa plataforma DOS visível. Mas o processo C ++ deve continuar rodando em segundo plano, invisível.
Se eu passar o scriptblock que contém variável, o código não parece funcionar. Isso ocorre porque o processo filho não herda as variáveis ​​do pai. Como posso superar isso?
Bruce, eu tenho andado por aí com runspaces para obter processamento em background de scriptblocks (em ps1.soapyfrog / 2007/01/22 / running-pipelines-in-the-background /)
Será que provavelmente veremos isso se tornando mais amigável nos próximos lançamentos?
Eu percebo que os runspaces estão realmente disponíveis para aplicativos host, mas eles parecem úteis.
Seu comentário no & quot; site de conexão do PowerShell & quot; é notado.
& # 8220; $ np = bloco de notas do processo get & # 8221; é * extemely * acertar ou errar se você usar muito o bloco de notas. Você poderia classificar os processos por data de início, criados por você, etc., em um esforço para mitigar os erros, mas sim & # 8211; deveríamos ter fornecido uma maneira de obter o processo mais recente criado em um runspace. Em vez de ter uma única variável $ LASTPROCESS, eu estava pensando que uma matriz de $ process ao longo das linhas de $ error seria legal. O processo criado mais recentemente seria mantido em $ process [0].
& gt; como o PowerShell é um shell, o controle de processos / tarefas não deve ser um cidadão de primeira classe.
Isso parece óbvio se não tivesse implementado um cmdlet New-Process / Start-Process, mas foi cortado do projeto em um ponto. Na triagem do que ocorreu na V1, nada além do gerenciamento básico de processos obteve uma classificação relativamente baixa, pois o PowerShell permite que você tenha acesso ao [Diagnostics. Process]. Isso significa que, embora possa ser complexo, você pode fazer praticamente qualquer coisa. Enviar é escolher como Jeffrey diz.
Poste uma solicitação no site de conexão do PowerShell para que outras pessoas possam modificá-lo. Esta é uma fonte de dados importante no processo de tiragem para o que vai para a próxima versão. Se um número suficiente de pessoas pedir, então ele vai para a lista curta do V. Next.
E, respondendo a um comentário anterior:
& gt; Qual é o poder de equivalência dos processos de inicialização em máquinas remotas, ele ainda usa o WMI?
As operações remotas no 1.0 exigem que você use o WMI, APIs remotos ou outros mecanismos de remoting existentes. O PowerShell 1.0 não possui recursos remotos explícitos. Suporte para remoting é um Pri 0 para o próximo lançamento.

Processo . Método WaitForExit ()
A documentação de referência da API tem uma nova casa. Visite o Navegador da API em docs. microsoft para ver a nova experiência.
Instrui o componente Process a aguardar indefinidamente que o processo associado seja encerrado.
Assembly: System (no System. dll)
A configuração de espera não pôde ser acessada.
Nenhuma identificação de processo foi definida e uma Handle da qual a propriedade Id pode ser determinada não existe.
Não há processo associado a este objeto Process.
Você está tentando chamar WaitForExit () para um processo que está sendo executado em um computador remoto. Este método está disponível apenas para processos em execução no computador local.
WaitForExit () faz com que o segmento atual espere até que o processo associado termine. Deve ser chamado depois que todos os outros métodos forem chamados no processo. Para evitar o bloqueio do segmento atual, use o evento Exited.
Este método instrui o componente Process a aguardar uma quantidade infinita de tempo para que os manipuladores de processo e evento saiam. Isso pode fazer com que um aplicativo pare de responder. Por exemplo, se você chamar CloseMainWindow para um processo que tenha uma interface com o usuário, a solicitação para o sistema operacional finalizar o processo associado poderá não ser tratada se o processo for gravado para nunca inserir seu loop de mensagem.
No Framework 3.5 e em versões anteriores, a sobrecarga WaitForExit () aguardava milissegundos MaxValue (aproximadamente 24 dias), não indefinidamente. Além disso, as versões anteriores não esperavam que os manipuladores de eventos saíssem se o tempo máximo de MaxValue fosse atingido.
Essa sobrecarga assegura que todo o processamento tenha sido concluído, incluindo o tratamento de eventos assíncronos para saída padrão redirecionada. Você deve usar essa sobrecarga após uma chamada para a sobrecarga WaitForExit (Int32) quando a saída padrão tiver sido redirecionada para manipuladores de eventos assíncronos.
Quando um processo associado é encerrado (ou seja, quando é encerrado pelo sistema operacional por meio de uma finalização normal ou anormal), o sistema armazena informações administrativas sobre o processo e retorna ao componente que chamou WaitForExit (). O componente de processo pode acessar as informações, que inclui o ExitTime, usando o identificador para o processo de saída.
Como o processo associado foi encerrado, a propriedade Handle do componente não aponta mais para um recurso de processo existente. Em vez disso, o identificador pode ser usado apenas para acessar as informações do sistema operacional sobre o recurso do processo. O sistema está ciente de identificadores para processos que não foram liberados pelos componentes do processo, portanto, ele mantém as informações de ExitTime e identificador na memória até que o componente de processo especificamente libera os recursos. Por esse motivo, sempre que você chamar a instância Start for Process, chame Close quando o processo associado tiver terminado e você não precisar mais de nenhuma informação administrativa sobre ele. Close libera a memória alocada para o processo finalizado.

Herança Múltipla.
Derivado de muitas coisas.
Os eventos Process. WaitForExit e. Exited não estão funcionando?
. NET System. Diagnostics. Process Class & # 8211; Parte 1.
Os eventos Process. WaitForExit e. Exited não estão funcionando? Eu pensei que tinha achado que este era o caso - mas foi minha culpa, provavelmente o mesmo para você também. Analisarei o que encontrei enquanto explorava e resolvia esse problema.
Resposta curta: Se você estiver redirecionando StandardOutput e / ou StandardError, use melhor os métodos assíncronos Process. BeginErrorReadLine () e. BeginOutputReadLine () ANTES de chamar. WaitForExit () e capture a saída enganchando os eventos Process. ErrorDataReceived e. OutputDataReceived.
A resposta longa começa comigo usando o arquivo Visual Studio diffmerge. exe na pasta Common7 / IDE para comparar arquivos de texto no modo em lotes. Eu estou introduzindo um teste de regressão em um processo em lote iniciado pela construção. Eu precisava de uma ferramenta que cuspisse um arquivo de diferenças de texto ao comparar dois arquivos (não um arquivo de resultado de mesclagem). O WinMerge e o Beyond Compare estão à minha disposição, mas eles não parecem produzir nada além de resultados mesclados (que normalmente é o que eu quero, mas não dessa vez).
Meu framework de regressão irá chamar diffmerge. exe e armazenar o arquivo diff resultante para revisão posterior. Eu codifiquei meu ProcessStartInfo…
Seguiu-se com o início do processo e aguardando que o processo terminasse ... e esperando ... espere esperando ....
Isso me fez ler o MSDN e aprofundar o uso da classe Process. Eu descobri algumas informações interessantes, provavelmente deveria ter sido óbvio.
Primeiro, descobri que, às vezes, executar meu processo filho do diffmerge com argumentos diferentes funcionava, às vezes não, o que tornava o assunto misterioso.
Em segundo lugar, descobri que funcionava bem quando eu não redirecionava a saída.
Então, obviamente, eu estava perdendo alguma coisa. Eu precisava ler os documentos da Process API e, assim, encontrei este nugget: Artigo do MSDN.
Depois de encontrar e ler esse artigo do MSDN eu entendi. Meu exemplo de código acima funcionará se o buffer StdOut ou StdError não estiver cheio. No entanto, o que eu estava vendo foi o buffer StdOut sendo preenchido, o processo filho foi bloqueado na próxima gravação StdOut / StdError, o processo pai estava aguardando infinitamente no processo filho para sair antes de ler o buffer StdOut / StdError. Para mim, parece que o método WaitForExit e / ou o evento Exited estão quebrados / não estão pegando o processo filho, mas foi meu código que foi quebrado.
Eu modifiquei o código para usar os métodos assíncronos e, de repente, meus problemas desapareceram. Não há mais bloqueio, tudo funcionou como esperado.
Eu usei StringBuilders como buffers para armazenar os dados recebidos nos eventos.
Na parte 2, me deparo com um problema com as implementações de ReadLine do processo StdOut / StdError em torno de minhas necessidades específicas, entro em como resolvi esse problema.

Msdn process waitforexit
A documentação de referência da API tem uma nova casa. Visite o Navegador da API em docs. microsoft para ver a nova experiência.
Instrui o componente Process a aguardar indefinidamente que o processo associado seja encerrado.
Assembly: System (no System. dll)
A configuração de espera não pôde ser acessada.
Nenhum processo foi definido e um do qual a propriedade pode ser determinada não existe.
Não há processo associado a este objeto Process.
Você está tentando chamar WaitForExit para um processo que está sendo executado em um computador remoto. Este método está disponível apenas para processos em execução no computador local.
WaitForExit faz o segmento atual esperar até que o processo associado termine. Deve ser chamado depois que todos os outros métodos forem chamados no processo. Para evitar o bloqueio do segmento atual, use o evento Exited.
Este método instrui o componente Process a aguardar uma quantidade infinita de tempo para que os manipuladores de processo e evento saiam. Isso pode fazer com que um aplicativo pare de responder. Por exemplo, se você chamar CloseMainWindow para um processo que tenha uma interface com o usuário, a solicitação para o sistema operacional finalizar o processo associado poderá não ser tratada se o processo for gravado para nunca inserir seu loop de mensagem.
No Framework 3.5 e em versões anteriores, a sobrecarga WaitForExit aguardava milissegundos MaxValue (aproximadamente 24 dias), não indefinidamente. Além disso, as versões anteriores não esperavam que os manipuladores de eventos saíssem se o tempo máximo de MaxValue fosse atingido.
Essa sobrecarga assegura que todo o processamento tenha sido concluído, incluindo o tratamento de eventos assíncronos para saída padrão redirecionada. Você deve usar essa sobrecarga após uma chamada para a sobrecarga WaitForExit quando a saída padrão tiver sido redirecionada para manipuladores de eventos assíncronos.
Quando um processo associado é encerrado (ou seja, quando é encerrado pelo sistema operacional por meio de uma finalização normal ou anormal), o sistema armazena informações administrativas sobre o processo e retorna ao componente que chamou WaitForExit. O componente Process pode, então, acessar as informações, que incluem o, usando o para o processo finalizado.
Como o processo associado foi encerrado, a propriedade do componente não aponta mais para um recurso de processo existente. Em vez disso, o identificador pode ser usado apenas para acessar as informações do sistema operacional sobre o recurso do processo. O sistema está ciente de identificadores para processos que não foram liberados pelos componentes do processo, portanto, ele mantém as informações e na memória até que o componente de processo especificamente libera os recursos. Por esse motivo, sempre que você chamar a instância Start for Process, chame Close quando o processo associado tiver terminado e você não precisar mais de nenhuma informação administrativa sobre ele. Close libera a memória alocada para o processo finalizado.
Veja a seção Remarks da página de referência da propriedade.