Erro cforeforexit c #

Exemplo de uso.

Resolvi assim:

Eu redirecionava a entrada, a saída e o erro e administrai a leitura dos fluxos de saída e erro. Esta solução funciona para o SDK 7- 8.1, tanto para o Windows 7 como para o Windows 8.

Eu tentei fazer uma aula que resolva seu problema usando a leitura de fluxo assíncrono, levando em conta Mark Byers, Rob, Stevejay responde. Ao fazê-lo, percebi que existe um erro relacionado à leitura assíncrona do fluxo de saída do processo.

Você não pode fazer isso:

Você receberá System. InvalidOperationException: StandardOut não foi redirecionado ou o processo ainda não começou.

Então, você deve iniciar a saída assíncrona lida após o processo ser iniciado:

Fazendo isso, faça uma condição de corrida porque o fluxo de saída pode receber dados antes de configurá-lo como assíncrono:

Então algumas pessoas podem dizer que você só precisa ler o fluxo antes de configurá-lo como assíncrono. Mas o mesmo problema ocorre. Haverá uma condição de corrida entre a leitura síncrona e configurará o fluxo em modo assíncrono.

Não há como conseguir uma leitura assíncrona segura de um fluxo de saída de um processo na forma real "Processo" e "ProcessStartInfo" foi projetado.

Você provavelmente está melhor usando a leitura assíncrona, como sugerido por outros usuários para o seu caso. Mas você deve estar ciente de que você pode perder algumas informações devido à condição de corrida.

Nenhuma das respostas acima está fazendo o trabalho.

A solução Rob trava e a solução 'Mark Byers' obtém a exceção descarta. (Eu tentei as "soluções" das outras respostas).

Então eu decidi sugerir outra solução:

Este código é depurado e funciona perfeitamente.

Eu acho que isso é uma abordagem simples e melhor (não precisamos do AutoResetEvent):

Eu estava tendo o mesmo problema, mas a razão era diferente. No entanto, isso aconteceria no Windows 8, mas não no Windows 7. A seguinte linha parece ter causado o problema.

A solução era NÃO desativar UseShellExecute. Agora recebi uma janela popup do Shell, que é indesejável, mas muito melhor do que o programa esperando que nada de particular aconteça. Então eu adicionei o seguinte trabalho para isso:

Agora, o único problema que me incomoda é o porquê isso está acontecendo no Windows 8, em primeiro lugar.

Introdução.

A resposta atualmente aceita não funciona (lança exceção) e há muitas soluções alternativas, mas nenhum código completo. Isso é, obviamente, desperdiçando muito tempo das pessoas porque esta é uma questão popular.

Combinando a resposta de Mark Byers e a resposta de Karol Tyl, escrevi um código completo baseado em como eu quero usar o método Process. Start.

Eu usei-o para criar um diálogo de progresso em torno dos comandos git. É assim que eu usei isso:

Em teoria, você também pode combinar stdout e stderr, mas não testei isso.

Eu sei que isso é velho, mas, depois de ler toda essa página, nenhuma das soluções estava funcionando para mim, embora eu não tentei Muhammad Rehan porque o código era um pouco difícil de seguir, embora eu acho que ele estava no caminho certo . Quando eu digo que não funcionou, isso não é inteiramente verdade, às vezes funcionaria bem, acho que é algo a ver com a duração da saída antes de uma marca EOF.

De qualquer forma, a solução que funcionou para mim era usar diferentes threads para ler o StandardOutput e StandardError e escrever as mensagens.

Espero que isso ajude alguém, que pensou que isso poderia ser tão difícil!

As outras soluções (incluindo o EM0) ainda estão bloqueadas para o meu aplicativo, devido a tempos de espera internos e ao uso de StandardOutput e StandardError pela aplicação gerada. Aqui está o que funcionou para mim:

Editar: inicialização adicionada de StartInfo para codificar a amostra.

Este post talvez esteja desactualizado, mas descobri a principal causa por que normalmente ele trava é devido ao excesso de pilha para o redirectStandardoutput ou se você tem redirectStandarderror.

Como os dados de saída ou os dados de erro são grandes, isso causará um tempo de espera, pois ele ainda está processando por tempo indefinido.

Processo . Método WaitForExit ()

A documentação de referência da API tem uma nova casa. Visite o navegador da API no docs. microsoft para ver a nova experiência.

Instrui o componente Processo a esperar indefinidamente para que o processo associado saia.

Assembly: System (no System. dll)

A configuração de espera não pôde ser acessada.

Nenhum Id do processo foi configurado e um identificador do qual a propriedade Id pode ser determinada não existe.

Não existe nenhum processo associado a este objeto Processo.

Você está tentando chamar WaitForExit () para um processo que está sendo executado em um computador remoto. Este método está disponível somente para processos que estão sendo executados no computador local.

WaitForExit () faz o thread atual aguardar até o processo associado terminar. Ele deve ser chamado após todos os outros métodos serem chamados no processo. Para evitar o bloqueio do segmento atual, use o evento Exitado.

Esse método instrui o componente Processo a aguardar uma quantidade infinita de tempo para que o processo e os manipuladores de eventos saem. Isso pode fazer com que um aplicativo pare de responder. Por exemplo, se você chamar CloseMainWindow para um processo que tenha uma interface de usuário, a solicitação ao sistema operacional para encerrar o processo associado pode não ser tratada se o processo for gravado para nunca entrar no loop de mensagem.

No Quadro 3.5 e versões anteriores, a sobrecarga WaitForExit () esperava milissegundos MaxValue (aproximadamente 24 dias), não indefinidamente. Além disso, as versões anteriores não esperaram que os manipuladores de eventos saíssem se o tempo MaxValue completo fosse atingido.

Esta sobrecarga garante que todo o processamento foi 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 foi redirecionada para manipuladores de eventos assíncronos.

Quando um processo associado sai (ou seja, quando é encerrado pelo sistema de operação através de um término normal ou anormal), o sistema armazena informações administrativas sobre o processo e retorna ao componente que chamou WaitForExit (). O componente Processo pode acessar a informação, que inclui o ExitTime, usando o Handle para o processo encerrado.

Como o processo associado saiu, a propriedade Handle do componente já não aponta 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 manipulações para processos que não foram lançados pelos componentes do Processo, portanto, mantém as informações ExitTime e Handle na memória até que o componente Processo liberte especificamente os recursos. Por esse motivo, sempre que você ligar para uma instância do Start for Process, chame Close quando o processo associado for encerrado e você não precisa mais de informações administrativas sobre isso. Fechar libera a memória alocada para o processo encerrado.

Consulte a seção Comentários da página de referência da propriedade StandardError.

para uma confiança total para o chamador imediato. Este membro não pode ser usado por código parcialmente confiável.

Processo . Método WaitForExit (Int32)

A documentação de referência da API tem uma nova casa. Visite o navegador da API no docs. microsoft para ver a nova experiência.

Instrui o componente Processo a aguardar o número especificado de milissegundos para que o processo associado saia.

Assembly: System (no System. dll)

Parâmetros.

A quantidade de tempo, em milissegundos, para aguardar o encerramento 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.

é verdade se o processo associado tenha saído; caso contrário, falso.

A configuração de espera não pôde ser acessada.

Nenhum Id do processo foi configurado e um identificador do qual a propriedade Id pode ser determinada não existe.

Não existe nenhum processo associado a este objeto Processo.

Você está tentando chamar WaitForExit (Int32) para um processo que está sendo executado em um computador remoto. Este método está disponível somente para processos que estão sendo executados no computador local.

WaitForExit (Int32) faz o thread atual aguardar até o processo associado terminar. Ele deve ser chamado após todos os outros métodos serem chamados no processo. Para evitar o bloqueio do segmento atual, use o evento Exitado.

Esse método instrui o componente Processo a aguardar um período finito de tempo para o processo sair. Se o processo associado não sair pelo final do intervalo porque a solicitação de término é negada, o falso é retornado ao procedimento de chamada. Você pode especificar um número negativo (Infinito) por milissegundos e Processar. WaitForExit (Int32) irá comportar-se da mesma forma que a sobrecarga WaitForExit (). Se você passar 0 (zero) para o método, ele retorna verdadeiro somente se o processo já foi encerrado; Caso contrário, ele retorna imediatamente falso.

No Quadro 3.5 e versões anteriores, se o milissegundo fosse -1, a sobrecarga WaitForExit (Int32) esperava 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 de eventos assíncrono tenha sido concluído, chame a sobrecarga WaitForExit () que não leva nenhum parâmetro depois de receber uma verdade dessa sobrecarga. Para ajudar a garantir que o evento Exited seja tratado corretamente nas aplicações Windows Forms, defina a propriedade SynchronizingObject.

Quando um processo associado é encerrado (é encerrado pelo sistema operacional através de uma terminação normal ou anormal), o sistema armazena informações administrativas sobre o processo e retorna ao componente que chamou WaitForExit (Int32). O componente Processo pode acessar a informação, que inclui o ExitTime, usando o Handle para o processo encerrado.

Como o processo associado saiu, a propriedade Handle do componente já não aponta 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 manipulações para processos que não foram lançados pelos componentes do Processo, portanto, mantém as informações ExitTime e Handle na memória até que o componente Processo liberte especificamente os recursos. Por esse motivo, sempre que você ligar para uma instância do Start for Process, chame Close quando o processo associado for encerrado e você não precisa mais de informações administrativas sobre isso. Fechar libera a memória alocada para o processo encerrado.

Consulte o exemplo de código para a propriedade ExitCode.

para uma confiança total para o chamador imediato. Este membro não pode ser usado por código parcialmente confiável.

Propriedade Process. EnableRaisingEvents.

A documentação de referência da API tem uma nova casa. Visite o navegador da API no docs. microsoft para ver a nova experiência.

Obtém ou define se o evento Exited deve ser gerado quando o processo terminar.

Assembly: System (no System. dll)

Valor da propriedade.

true se o evento Exited deve ser gerado quando o processo associado for encerrado (através de uma saída ou uma chamada para Kill); caso contrário, falso. O padrão é falso .

A propriedade EnableRaisingEvents indica se o componente deve ser notificado quando o sistema operacional encerrou um processo. A propriedade EnableRaisingEvents é usada em processamento assíncrono para notificar seu aplicativo que um processo foi encerrado. Para forçar o seu aplicativo a esperar de forma síncrona para um evento de saída (que interrompe o processamento do aplicativo até o evento de saída ter ocorrido), use o método WaitForExit.

Se você estiver usando o Visual Studio e clicando duas vezes em um componente de Processo em seu projeto, um delegado de eventos e eventos executados será gerado automaticamente. Código adicional define a propriedade EnableRaisingEvents como falso. Você deve alterar essa propriedade como verdadeira para o seu manipulador de eventos ser executado quando o processo associado for encerrado.

Quando um processo associado sai depois de ser desligado pelo sistema operacional através de uma terminação normal ou anormal, o sistema operacional notifica cada componente de processo ao qual o processo foi associado, desde que o valor EnableRaisingEvents do componente seja verdadeiro. Se um componente iniciou o processo, o componente pode acessar as informações administrativas para o processo associado, que ainda está sendo armazenado pelo sistema operacional. Essas informações incluem o ExitTime e o ExitCode.

Após o processo associado sair, o identificador do componente já não aponta para um recurso de processo existente. Em vez disso, ele pode ser usado apenas para acessar as informações do sistema operacional sobre o recurso do processo. O sistema operacional está ciente de que existem alças para processos encerrados que não foram lançados pelos componentes do Processo, portanto, mantém as informações ExitTime e Handle na memória.

Há um custo associado à procura de um processo para sair. Se EnableRaisingEvents for verdadeiro, o evento Exited será gerado quando o processo associado terminar. Os procedimentos que você especificou para o evento Exited são executados nesse momento.

Às vezes, seu aplicativo inicia um processo, mas não precisa ser notificado de seu encerramento. Por exemplo, seu aplicativo pode iniciar o Bloco de notas para permitir que o usuário execute a edição de texto, mas não faça mais uso do aplicativo do bloco de notas. Você pode optar por não ser notificado quando o processo sair, porque não é relevante para a continuação da operação do seu aplicativo. Configurar EnableRaisingEvents para false guarda os recursos do sistema.

O exemplo de código a seguir cria um processo que imprime um arquivo. Ele define a propriedade EnableRaisingEvents para fazer com que o processo eleve o evento Exitado quando ele sair. O manipulador de eventos Exit apresenta as informações do processo.

para uma confiança total para o chamador imediato. Este membro não pode ser usado por código parcialmente confiável.

Свойство Process. StandardError.

Опубликовано: Октябрь 2018.

Возвращает поток, используемый для чтения ошибок вне приложения.

Значение свойства.

Объект StreamReader, используемый для приложения.

Поток StandardError был открыт для асинхронных операций чтения с BeginErrorReadLine.

Quando um T: System. Diagnostics. Process grava texto em seu fluxo de erro padrão, esse texto normalmente é exibido no console. Redirecionando o fluxo P: System. Diagnostics. Process. StandardError, você pode manipular ou suprimir a saída de erro de um processo. Por exemplo, você pode filtrar o texto, formatá-lo de forma diferente ou escrever a saída para o console e um arquivo de log designado.

Para usar P: System. Diagnostics. Process. StandardError, você deve definir P: System. Diagnostics. ProcessStartInfo. UseShellExecute como falso, e você deve definir P: System. Diagnostics. ProcessStartInfo. RedirectStandardError para true. Caso contrário, lendo do fluxo P: System. Diagnostics. Process. StandardError lança uma exceção.

O fluxo P: System. Diagnostics. Process. StandardError redirecionado pode ser lido de forma síncrona ou assíncrona. Métodos como M: System. IO. StreamReader. Read, M: System. IO. StreamReader. ReadLine e M: System. IO. StreamReader. ReadToEnd executam operações de leitura síncrona no fluxo de saída de erro do processo. Essas operações de leitura síncrona não são concluídas até que o T: System. Diagnostics. Process associado grava seu fluxo P: System. Diagnostics. Process. StandardError ou fecha o fluxo.

Em contraste, M: System. Diagnostics. Process. BeginErrorReadLine inicia operações de leitura assíncronas no fluxo P: System. Diagnostics. Process. StandardError. Este método habilita um manipulador de eventos designado para a saída do fluxo e retorna imediatamente ao chamador, o que pode executar outro trabalho enquanto a saída do fluxo é direcionada para o manipulador de eventos.

As operações de leitura síncrona introduzem uma dependência entre a leitura do chamador a partir do fluxo P: System. Diagnostics. Process. StandardError e a escrita do processo filho a esse fluxo. Essas dependências podem resultar em condições de impasse. Quando o chamador lê do fluxo redirecionado de um processo filho, depende da criança. O chamador aguarda a operação de leitura até que a criança grava a transmissão ou encerre o fluxo. Quando o processo filho grava dados suficientes para preencher o fluxo redirecionado, ele depende do pai. O processo filho aguarda a próxima operação de gravação até que o pai lê do fluxo completo ou fecha o fluxo. A condição de deadlock resulta quando o processo do chamador e filho aguardam um para o outro para concluir uma operação, e nenhum deles pode prosseguir. Você pode evitar deadlocks avaliando as dependências entre o chamador eo processo filho.

O seguinte código C #, por exemplo, mostra como ler de um fluxo redirecionado e aguarde o processo filho sair.

O exemplo de código evita uma condição de bloqueio chamando p. StandardError. ReadToEnd antes de p. WaitForExit. Uma condição de impasse pode resultar se o processo pai chama p. WaitForExit antes de p. StandardError. ReadToEnd e o processo filho grava texto suficiente para preencher o fluxo redirecionado. O processo pai esperaria indefinidamente para que o processo filho saísse. O processo filho esperaria indefinidamente para o pai ler do fluxo completo P: System. Diagnostics. Process. StandardError.

Há um problema semelhante ao ler todo o texto da saída padrão e dos fluxos de erro padrão. O código C # a seguir, por exemplo, executa uma operação de leitura em ambos os fluxos.

O exemplo de código evita a condição de bloqueio executando operações de leitura assíncronas no fluxo P: System. Diagnostics. Process. StandardOutput. Um estado de impasse resulta se o processo pai chamar p. StandardOutput. ReadToEnd seguido de p. StandardError. ReadToEnd e o processo filho escreve texto suficiente para preencher o fluxo de erros. O processo pai aguardaria indefinidamente o processo filho para fechar o fluxo P: System. Diagnostics. Process. StandardOutput. O processo filho esperaria indefinidamente para o pai ler do fluxo completo P: System. Diagnostics. Process. StandardError.

Você pode usar operações de leitura assíncronas para evitar essas dependências e seu potencial de impasse. Alternativamente, você pode evitar a condição de bloqueio criando dois tópicos e lendo a saída de cada fluxo em um segmento separado.

Você não pode misturar operações de leitura assíncronas e síncronas em um fluxo redirecionado. Uma vez que o fluxo redirecionado de um T: System. Diagnostics. Process é aberto em modo assíncrono ou síncrono, todas as operações de leitura adicionais nesse fluxo devem estar no mesmo modo. Por exemplo, não siga M: System. Diagnostics. Process. BeginErrorReadLine com uma chamada para M: System. IO. StreamReader. ReadLine no fluxo P: System. Diagnostics. Process. StandardError ou vice-versa. No entanto, você pode ler dois fluxos diferentes em modos diferentes. Por exemplo, você pode chamar M: System. Diagnostics. Process. BeginOutputReadLine e, em seguida, chama M: System. IO. StreamReader. ReadLine para o fluxo P: System. Diagnostics. Process. StandardError.

O exemplo a seguir usa o comando net use junto com um argumento fornecido pelo usuário para mapear um recurso de rede. Em seguida, lê o fluxo de erros padrão do comando net e o escreve para console.

para uma confiança total para o chamador imediato. Este membro não pode ser usado por código parcialmente confiável.