C # redirectstandardoutput waitforexit

C # redirectstandardoutput waitforexit
Obter através da App Store Leia esta publicação em nosso aplicativo!
ProcessStartInfo WaitForExit Timeout.
Preciso imprimir um arquivo pdf com ProcessStartInfo.
O nome do arquivo e os argumentos são corretos eles funcionam quando colados em cmd. O código funciona corretamente, mas após Process. Start quando se trata de WaitForExit, o programa não termina. Recebo o erro de tempo limite:
System. Threading. ThreadAbortException: Thread estava sendo abortado. no System. Threading. WaitHandle. WaitOneNative (SafeHandle waitableSafeHandle, UInt32 millisecondsTimeout, Boolean hasThreadAffinity, Boolean exitContext) no System. Threading. WaitHandle. InternalWaitOne (SafeHandle waitableSafeHandle, Int64 milissegundosTimeout, Boolean hasThreadAffinity, Boolean exitContext) no System. Diagnostics. Process. WaitForExit (Int32 milissegundos).
Eu procurei e tentei algumas coisas como configurar & lt; httpRuntime executionTimeout = "300" / & gt; e execute um 500 ou como no código com process. WaitForExit (6000); e mais alto, onde nenhum exeption, mas nada foi impresso.
Existe um erro ou estou faltando alguma coisa?
EDIT: Eu mudei meu bloco de código acima. Agora, o código funciona no modo de depuração, mas ainda não imprimirá meu documento quando publicado. Eu também tentei usar um Usuário diferente. No modo de depuração, o código imprime o documento, mas é executado na consulta kill.
O ProcessStartInfo. Verbs retorna uma Exceção de argumento, mas eu não sei por quê.
Depois de muita tentativa, teste e pesquisa, tenho certeza que meu código funciona. Então eu ainda não sei por que meu código parou de funcionar. Mas a mudança do Adobe Reader 9.0 no servidor para 7.0 agora funciona.
Quando eu estava depurando localmente com o Adobe Reader 9.0 também funcionava, então eu acho que talvez houvesse uma atualização no servidor web. Eu não testei isso ainda.

C # redirectstandardoutput waitforexit
Obter através da App Store Leia esta publicação em nosso aplicativo!
Process. start: como obter o resultado?
Gostaria de executar um programa de linha de comando externo do meu Mono / app. Por exemplo, eu gostaria de executar o mencoder. É possível:
Para obter a saída do shell da linha de comando e gravá-la na minha caixa de texto? Para obter o valor numérico para mostrar uma barra de progresso com o tempo decorrido?
Quando você cria seu objeto de processo, defina StartInfo de forma adequada:
então comece o processo e leia:
Você pode usar int. Parse () ou int. TryParse () para converter as seqüências de caracteres em valores numéricos. Você pode ter que fazer alguma manipulação de seqüência primeiro se houver caracteres numéricos inválidos nas cordas que você lê.
Você pode processar sua saída de forma síncrona ou assíncrona.
Observe que é melhor processar a saída e os erros: eles devem ser tratados separadamente.
(*) Para alguns comandos (aqui StartInfo. Arguments) você deve adicionar a diretiva / c, caso contrário, o processo congelará no WaitForExit ().
Se você não precisa fazer operações complicadas com a saída, você pode ignorar o método OutputHandler, apenas adicionando os manipuladores diretamente em linha:
A maneira padrão de fazer isso é ler do fluxo de Processo StandardOutput. Existe um exemplo nos documentos do MSDN vinculados. Da mesma forma, você pode ler do StandardError e gravar em StandardInput.
Tudo bem, para quem quer que ambos os Erros e Saídas leiam, mas obtém deadlocks com qualquer uma das soluções, fornecidas em outras respostas (como eu), aqui está uma solução que eu construí depois de ler a explicação MSDN para a propriedade StandardOutput.
A resposta é baseada no código do T30:
você pode usar memória compartilhada para os 2 processos para se comunicar, verifique o MemoryMappedFile.
você criará principalmente um arquivo mestre de memória mmf no processo pai usando a instrução "using", então crie o segundo processo até que ele termine e deixe-o escrever o resultado no mmf usando o BinaryWriter, então leia o resultado do mmf usando o processo pai , você também pode passar o nome mmf usando argumentos de linha de comando ou código rígido.
Certifique-se de que, ao usar o arquivo mapeado no processo pai, você faz o processo filho gravar o resultado no arquivo mapeado antes que o arquivo mapeado seja liberado no processo pai.
Exemplo: processo pai.
Para usar este exemplo, você precisará criar uma solução com 2 projetos dentro, então você leva o resultado de compilação do processo filho de% childDir% / bin / debug e copiá-lo para% parentDirectory% / bin / debug, em seguida, execute o projeto pai.
childDir e parentDirectory são os nomes das pastas dos seus projetos no pc boa sorte :)
Isso depende do mencoder. Se ele atingir esse status na linha de comando, então sim :)

C # redirectstandardoutput waitforexit
Obter através da App Store Leia esta publicação em nosso aplicativo!
StandardOutput. ReadToEnd () trava [duplicado]
Esta questão já tem uma resposta aqui:
Eu tenho um programa que freqüentemente usa um programa externo e lê suas saídas. Isso funciona muito bem, usando seu processo usual de redirecionamento de saída, mas um argumento específico, por algum motivo, trava quando eu tento lê-lo, nenhuma mensagem de erro - nenhuma exceção, apenas "pára" quando ele atinge essa linha. Naturalmente, eu uso uma função centralizada para chamar e ler a saída do programa, o que é o seguinte:
A linha que trava é resultado = proc. StandardOutput. ReadToEnd (); , mas novamente, não todas as vezes, somente quando enviado um argumento específico ("start-server"). Todos os outros argumentos funcionam bem - lê o valor e o retorna. Também é estranho o jeito que ele trava. Não congela ou comete um erro ou qualquer coisa, ele simplesmente pára o processamento. Como se fosse um comando de "retorno", exceto que ele nem sequer retorna à função de chamada, ele simplesmente pára tudo com a interface ainda está funcionando. Alguém experimentou isso antes? Alguém tem alguma ideia do que eu deveria tentar? Estou assumindo que é algo inesperado dentro do fluxo em si, mas existe uma maneira de lidar / ignorar isso para que ele lê de qualquer maneira?
marcado como duplicado por Peter Duniho c # Usuários com o crachá c # podem fechar as perguntas de c # como duplicatas e reabri-las conforme necessário. 27 de junho às 2:45.
Esta pergunta foi feita antes e já tem uma resposta. Se essas respostas não respondem totalmente a sua pergunta, faça uma nova pergunta.
As soluções propostas com BeginOutputReadLine () são uma boa maneira, mas em situações como essa, não é aplicável, porque o processo (certamente com o uso de WaitForExit ()) sai antes da saída assíncrona concluída completamente.
Então, tentei implementá-lo de forma síncrona e descobriu que a solução é usar o método Peek () da classe StreamReader. Eu adicionei check for Peek () & gt; -1 com certeza que não é o fim do fluxo como no artigo MSDN descrito e, finalmente, funciona e pára de pendurar!
Aqui está o código:
O problema é que você está usando os métodos síncronos ReadToEnd nos fluxos StandardOutput e StandardError. Isso pode levar a um potencial bloqueio que você está enfrentando. Isto é mesmo descrito no MSDN. A solução está descrita lá. Basicamente, é: use a versão assíncrona BeginOutputReadLine para ler os dados do fluxo StandardOutput:
Eu tive o mesmo problema de impasse. Este trecho de código funcionou para mim.
E quanto a algo como:
Eu tive o mesmo tipo de problema que o erro estava pendurado.
Com base na sua resposta a Daniel Hilgarth, nem tentei usar esses códigos, embora eu pense que eles teriam funcionado para mim.
Uma vez que eu quero ser capaz de fazer alguma saída mais fantástica ainda, eu decidi que eu faria isso com as duas saídas sendo feitas em uma linha de fundo.
Isso funcionou para mim e me permitiu não ter que usar um tempo limite para a leitura.
Algo que é elegante e trabalhou para mim é:
Esta resposta eu encontrei aqui e o truque está usando Flush () e Close () na entrada padrão.
A solução da resposta aceita não funcionou para mim. Eu tive que usar tarefas para evitar o impasse:
Com uma função GetStreamOutput da seguinte maneira:
Apenas no caso de alguém se tropeçar com esta questão, enquanto estiver usando Windows Forms e TextBox (ou RichTextBox) para mostrar os erros e as saídas, o processo retorna em tempo real (como eles são escritos para process. StandardOutput / process. StandardError).
Você precisa usar OutputDataReceived () / ErrorDataReceived () para ler ambos os fluxos sem deadlocks, não há maneira (tanto quanto eu sei) para evitar deadlocks de outra forma, mesmo a resposta de Fedor, que agora contém a tag "Answer" e o A maioria gosta de atualizar, não faz o truque para mim.
No entanto, quando você usa o RichTextBox (ou TextBox) para enviar os dados, outro problema que você encontra é como realmente gravar os dados na caixa de texto em tempo real (uma vez que ele chega). Você recebe o acesso aos dados dentro de um dos segmentos de fundo OutputDataReceived () / ErrorDataReceived () e você só pode anexar o texto () do thread principal.
O que eu tentei pela primeira vez era chamar processo. Iniciar () de uma linha de fundo e, em seguida, chamar BeginInvoke () = & gt; AppendText () nos segmentos OutputDataReceived () / ErrorDataReceived () enquanto o thread principal era process. WaitForExit ().
No entanto, isso levou a minha forma a congelar e finalmente pendurar por toda a eternidade. Depois de alguns dias de tentativa, acabei com a solução abaixo, que parece funcionar muito bem.
Em breve, você precisa adicionar as mensagens em uma coleção concorrente dentro dos segmentos OutputDataReceived () / ErrorDataReceived () enquanto o segmento principal deve tentar constantemente extrair as mensagens dessa coleção e anexá-las na caixa de texto:

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.