Standardoutput readtoend waitforexit

Honey Mercy.
Apenas outro site do WordPress.
[] Solução: WaitForExit NÃO é executado após Process. Start ()
WaitForExit NÃO é executado após Process. Start () é chamado.
Quando um Processo grava texto em seu fluxo padrão, esse texto normalmente é exibido no console. Ao redirecionar o fluxo StandardOutput, você pode manipular ou suprimir a saída 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.
O fluxo de saída StandardOutput redirecionado pode ser lido de forma síncrona ou assíncrona. Métodos como Read, ReadLine e ReadToEnd executam operações de leitura síncrona no fluxo de saída do processo. Essas operações de leitura síncrona não são concluídas até que o Processo associado escreva seu fluxo StandardOutput ou encerre o fluxo.
Em contraste, BeginOutputReadLine inicia operações de leitura assíncronas no fluxo StandardOutput. 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 do fluxo StandardOutput e a escrita do processo filho para 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. StandardOutput. ReadToEnd antes de p. WaitForExit. Uma condição de impasse pode resultar se o processo pai chama p. WaitForExit antes de p. StandardOutput. ReadToEnd eo processo filho grava texto suficiente para preencher o fluxo redirecionado. O processo pai aguardaria indefinidamente o processo filho para sair. O processo filho esperaria indefinidamente para o pai ler do fluxo de StandardOutput completo.
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 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 StandardOutput. O processo filho esperaria indefinidamente para o pai ler do fluxo completo do 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.
Relacionados.
Pós-navegação.
Deixe uma resposta Cancelar resposta.
O que é para todos os corpos, é o meu primeiro a ver esse blog; Esta página contém dados incríveis e verdadeiramente excelentes em apoio aos visitantes.

Standardoutput readtoend waitforexit
Obter através da App Store Leia esta publicação em nosso aplicativo!
ReadToEnd da saída de processo std e waitforexit.
Do exemplo do MSDN de usar stdoutput do processo recém-criado:
Se, em vez de myStreamReader. ReadLine (), estou usando myStreamReader. ReadToEnd () devo continuar usando myProcess. WaitForExit ()? Ou ReadToEnd () aguardará até que o processo seja concluído?
EDIT: Desculpe pelo desvio, para responder diretamente a sua pergunta. Sim, você precisa chamar Process. WaitForExit (); . Isso garantirá que o processo tenha produzido toda a sua saída antes de chamar ReadToEnd ()
ReadToEnd é função síncrona. Portanto, se você não o chamar em seu código, ele bloqueará seu segmento principal até que ele capture apenas o primeiro resultado do StandardOutput, então é isso. Mas usando WaitForExit irá garantir que você tenha tudo.
Além disso, você pode considerar fazer uma leitura assíncrona da saída do processo, veja este Exemplo MSDN que implementa OutputDataRecieved.
"ReadToEnd" é uma função armazenada no objeto "StreamReader" e não acho que tenha algo a ver com a espera de um processo para sair, no entanto, a classe "Processo" pode lidar com isso. Por sinal, todas as habilidades "StreamReader" não são úteis na situação que você mencionou.
No meu ponto de vista, "WaitForExit" deve ser chamado e, como você fez "Fechar" também. Porque eles vão divulgar alguns recursos do sistema que nenhum outro método pode. Tanto quanto eu sei, o método "ReadToEnd" não tem nada a ver com chamar esses dois.

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.

Standardoutput readtoend waitforexit
Estou desenvolvendo um aplicativo de console C # que inicia uma linha de comando e obtém alguns dados através de outro comando (o que é irrelevante nesta discussão). Eventualmente, vou obter alguns dados na linha de comando e eu só preciso apenas da última linha disso.
Uma vez que cada vez que os dados que recebo no console diferem, não consigo codificar qualquer ação específica de onde obter minha saída.
Estou recebendo uma exceção de tempo limite de função.
Marcado como resposta por Jack 321 segunda-feira, 11 de agosto de 2008 5:43 da manhã.
System. Diagnostics. ProcessStartInfo psi = new System. Diagnostics. ProcessStartInfo (& quot; seu processo & quot;);
System. IO. StreamWriter sIn;
System. IO. StreamReader sOut;
// Anexe a saída para leitura.
// Anexe a entrada para escrita.
sIn. WriteLine (& quot; Write your command & quot;);
string strOutput = sOut. ReadToEnd ();
// Feche o io Streams;
// tire a última linha do strOutput.
Marcado como resposta por Jack 321 segunda-feira, 11 de agosto de 2008 5:43 da manhã.
Primeiro, enviei o & quot; ipconfig & quot; comando, com um readToEnd ();
Tentou ler em blocos, também falhou.
Tentou waitForInputIddle () ;, mas esqueceu que cmd não possui interface gráfica, também falhou.
sIn. WriteLine (& quot; ipconfig / all & quot;);
O improvável que fazemos, o impossível demora um pouco mais. - Steven Parker.
Marcado como resposta por Jack 321 segunda-feira, 11 de agosto de 2008 5:44.
Marcado como resposta por Jack 321 segunda-feira, 11 de agosto de 2008 5:44.
Todas as respostas.
Marcado como resposta por Jack 321 segunda-feira, 11 de agosto de 2008 5:43 da manhã.
System. Diagnostics. ProcessStartInfo psi = new System. Diagnostics. ProcessStartInfo (& quot; seu processo & quot;);
System. IO. StreamWriter sIn;
System. IO. StreamReader sOut;
// Anexe a saída para leitura.
// Anexe a entrada para escrita.
sIn. WriteLine (& quot; Write your command & quot;);
string strOutput = sOut. ReadToEnd ();
// Feche o io Streams;
// tire a última linha do strOutput.
Marcado como resposta por Jack 321 segunda-feira, 11 de agosto de 2008 5:43 da manhã.
No entanto, o que há acima é uma resposta padrão muito boa.
Eu não acho que o "cmd" termina o fluxo. Não há nada enviado a partir do cmd-box para indicar que o fluxo está encerrado.
Considere uma página da Web que você carrega, uma vez que o código html inteiro chegou ao seu PC, o fluxo está pronto. Mesmo com a leitura de um arquivo, uma vez que você alcançou o último personagem, o fluxo está pronto. No entanto, com cmd, o fluxo não é "feito". Ele apenas espera uma nova entrada, então, se você der um outro comando, ele terá saída novamente.
De qualquer forma, não acho que haja nada que você possa fazer para usar ReadToEnd () em um fluxo de saída cmd, a menos que você envie o & quot; exit & quot; comando.
O improvável que fazemos, o impossível demora um pouco mais. - Steven Parker.
Primeiro, enviei o & quot; ipconfig & quot; comando, com um readToEnd ();
Tentou ler em blocos, também falhou.
Tentou waitForInputIddle () ;, mas esqueceu que cmd não possui interface gráfica, também falhou.
sIn. WriteLine (& quot; ipconfig / all & quot;);
O improvável que fazemos, o impossível demora um pouco mais. - Steven Parker.
Marcado como resposta por Jack 321 segunda-feira, 11 de agosto de 2008 5:44.
Marcado como resposta por Jack 321 segunda-feira, 11 de agosto de 2008 5:44.
A Microsoft está conduzindo uma pesquisa on-line para entender sua opinião sobre o site da Msdn. Se você optar por participar, a pesquisa on-line será apresentada quando você deixar o site Msdn.

Propriedade Process. StandardOutput.
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 um fluxo usado para ler o resultado textual da aplicação.
Assembly: System (no System. dll)
Valor da propriedade.
Um StreamReader que pode ser usado para ler o fluxo de saída padrão do aplicativo.
O fluxo StandardOutput foi aberto para operações de leitura assíncronas com BeginOutputReadLine.
Quando um Processo grava texto em seu fluxo padrão, esse texto normalmente é exibido no console. Ao redirecionar o fluxo StandardOutput, você pode manipular ou suprimir a saída 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 StandardOutput, você deve definir ProcessStartInfo. UseShellExecute como falso, e você deve definir ProcessStartInfo. RedirectStandardOutput como verdadeiro. Caso contrário, a leitura do fluxo StandardOutput lança uma exceção.
O fluxo de saída StandardOutput redirecionado pode ser lido de forma síncrona ou assíncrona. Métodos como Read, ReadLine e ReadToEnd executam operações de leitura síncrona no fluxo de saída do processo. Essas operações de leitura síncrona não são concluídas até que o Processo associado escreva seu fluxo StandardOutput ou encerre o fluxo.
Em contraste, BeginOutputReadLine inicia operações de leitura assíncronas no fluxo StandardOutput. 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 do fluxo StandardOutput e a escrita do processo filho para 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. StandardOutput. ReadToEnd antes de p. WaitForExit. Uma condição de impasse pode resultar se o processo pai chama p. WaitForExit antes de p. StandardOutput. ReadToEnd eo processo filho grava texto suficiente para preencher o fluxo redirecionado. O processo pai aguardaria indefinidamente o processo filho para sair. O processo filho esperaria indefinidamente para o pai ler do fluxo de StandardOutput completo.
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 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 StandardOutput. O processo filho esperaria indefinidamente para o pai ler do fluxo completo do 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 Processo é 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 BeginOutputReadLine com uma chamada para ReadLine no fluxo StandardOutput ou vice-versa. No entanto, você pode ler dois fluxos diferentes em modos diferentes. Por exemplo, você pode chamar BeginOutputReadLine e, em seguida, chamar ReadLine para o fluxo StandardError.
O exemplo a seguir executa o comando ipconfig. exe e redireciona sua saída padrão para a janela de console do exemplo.
para uma confiança total para o chamador imediato. Este membro não pode ser usado por código parcialmente confiável.