Waitoutxit timeout não está funcionando

Waitforexit timeout não funciona
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.

Esperando um processo com tempo limite em.
Na mesma linha da minha última publicação, podemos querer ser mais inteligentes sobre o lançamento de um processo e aguardamos a saída.
Particularmente, se esse processo for parte de um sistema crítico, como seu processo de compilação, você não quer que um processo suspenso seja capaz de fazer com que seu sistema de compilação inteiro pare de morrer nas suas faixas.
Felizmente, o Processo tem uma sobrecarga de WaitForExit que leva um tempo limite inteiro e retorna um booleano - verdadeiro se o processo for encerrado ou falso se o processo não acontecesse.
Usando esta função, podemos escrever um método como este:
Neste trecho, OutputDataReceived é um evento que dispara quando o processo grava dados em saída padrão e sinais BeginOutputReadLine para que configuramos nosso evento e estamos prontos para começar a ouvir a saída do processo.
Usar o formulário de evento neste caso significa que não precisamos ter o texto de saída completo do processo na memória em nenhum momento. À medida que o processo escreve uma linha de texto, teremos apenas essa linha na memória, e isso será coletado por lixo depois de atualizar nosso contador.
Há dois "gotcha" s neste trecho, no entanto.
O primeiro é process. Kill (). Esta é uma condição de corrida clássica - entre o tempo em que nosso processo retorna de process. WaitForExit () e invoca processo. Kill (), o processo de destino pode sair. Nesse caso, o MSDN afirma que, se você chamar. Kill () em um processo que já saiu, você receberá uma InvalidOperationException.
Podemos corrigir isso, manipulando a exceção, assim:
O segundo "gotcha" é muito sutil, e você provavelmente não o achará até que a função não retorne o resultado esperado, ou até se sentar e ler toda a página de documentação para Process. WaitForExit (int). O MDSN afirma que:
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.
Nesse caso, é possível que nossa função GetNumOutputChars devolva um valor que contenha menos caracteres do que a saída real do processo, a menos que chamemos WaitForExit () novamente.
Com isso em mente, nossa função de segurança final agora se parece com isto:

George Birbilis @zoomicon.
Engenheiro de informática, Microsoft MVP J # & # 8211; R & amp; D 2004-2018, Borland Spirit of Delphi 2001.
Gotchas at Wait para um aplicativo descascado terminar (com / sem tempo limite) com.
Encontrei um exemplo útil do suporte da Microsoft chamado "Como aguardar a conclusão de um aplicativo descascado usando Visual Basic 2005 ou Visual Basic" em support. microsoft/kb/305368.
No entanto, note que existem várias gotchas com o código fornecido lá (apenas informou a Microsoft sobre isso, espero que eles tomem nota). Também o artigo aponta para as versões C # e C ++ da amostra que, obviamente, precisam das mesmas correções.
1) existe um problema tanto na primeira amostra (espere indefinidamente) como no segundo (espera com tempo limite)
& # 8216; Aguarde a janela de processo para concluir o carregamento.
& # 8216; Aguarde até que o processo saia.
Por que esperar pela entrada ocioso em primeiro lugar? O processo pode nunca entrar no estado ocioso e sair antes disso. De acordo com msdn. microsoft/en-us/library/8d7363e2(v=VS.90).aspx, você pode obter exceção de WaitForInputIdle:
Ocorreu um erro desconhecido. O processo não conseguiu entrar no estado ocioso.
O processo já foi encerrado.
Nenhum processo está associado a este objeto Processo.
Suponho que seja melhor evitar chamar WaitForInputIdle, pois você apenas se importa com WaitForExit lá.
2) Mesmo WaitForExit pode lançar exceções que o código deve verificar de acordo com msdn. microsoft/en-us/library/fb4aw7b8.aspx.
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.
3) O artigo de suporte não menciona o documento WaitForExit (timeout) (msdn. microsoft/en-us/library/fb4aw7b8.aspx) sobre o tempo limite "infinito":
No Framework versão 3.5 e versões anteriores, a sobrecarga WaitForExit aguardava 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.
Além disso, parece que a documentação para "WaitForExit (timeout)" não menciona que existe uma constante Timeout. Infinite que tem o valor -1 a usar para tais tempos limite infinitos (encontrado a partir do documento de Thread. Join): msdn. microsoft/ en-us / library / system. threading. timeout. infinite (v = VS.90).aspx.
4) A amostra não consegue chamar Close e, portanto, continua a gastar recursos para controlar o rastreamento (e "bloquear" aqueles identificadores de identificadores, obviamente, embora não seja tão fácil quanto em CPUs antigas e versões do sistema operacional ficar sem alças, espero).
Quando um processo associado sai (ou seja, quando é desligado 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 a informação do sistema operacional n. ° 8217 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.
Observe também que poderia ter uma cláusula "Usando" ao definir o novo objeto de processo (em vez de Dim) em vez de obrigar explicitamente a "Processar fechar" no final para liberar recursos, conforme observado em msdn. microsoft/en - us / library / system. diagnostics. process. close (v = VS.90).aspx.
O método Fechar faz com que o processo pare de aguardar a saída se ele estivesse esperando, fecha o identificador do processo e limpa as propriedades específicas do processo. Fechar não fecha os leitores e escritores padrão de saída, entrada e erro caso estejam sendo referenciados externamente.
O método Dispose (Boolean) chama Close. Colocar o objeto Processo em um bloco de uso dispõe de recursos sem a necessidade de chamar Close.
5) Outro problema está na 2ª amostra (aguarde com tempo limite). Não menciona ter que chamar WaitForExit () novamente sem params após o WaitForExit (timeout) no caso em que a saída padrão foi redirecionada para manipuladores de eventos assíncronos (deve mencionar este caso para completude)
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.

Erro no processo Mono.
Calling System. Diagnostics. Process. WaitForExit () pouco depois de um Java. Lang. Process ter executado muitas vezes trava até o processo ter terminado.
Anexei uma demonstração simples do projeto Xamarin. Android que exibe esse comportamento. Ele invoca o comando do terminal 'id' usando System. Diagnostics. Processo dez vezes, então invoca o mesmo comando usando Java. Lang. Process, então ele repete a invocação System. Diagnostics. Process dez vezes. Pressionar o botão na UI invocará essa seqüência de comandos e os resultados serão exibidos no logcat ou na janela de saída do aplicativo.
O comando 'id' é determinista e esperamos que as chamadas de processo terminem rapidamente, no entanto, cerca de 20% do tempo, uma ou mais das chamadas System. Diagnostic. Processo trava no WaitForExit, que tem um tempo limite de cinco segundos. Em todos os casos, o comando parece ter sido concluído porque 'ps' não informa que está sendo ativo e o buffer de entrada contém os dados esperados e foi lido no final do fluxo.
O modo de falha ocorre apenas se você já executou o Java. Lang. Process e parece se classificar após um pequeno número de falhas (geralmente duas). Se você comentar a invocação de Java. Lang. Process, o problema nunca ocorre.
Nossa teoria de trabalho é que ambos os métodos para a invocação do processo dependem de um conjunto comum de recursos, possivelmente manipula, e que esse pool fica temporariamente corrompido. Não é, obviamente, relacionado ao segmento como cada invocação é executada sequencialmente.
Outras evidências de interesse incluem o tempo ocasional de Java. Lang. Process. WaitFor () em circunstâncias semelhantes. É comentado no projeto de exemplo em anexo porque o tempo limite do WaitForExit faz uma demonstração mais limpa. Adicione-o de volta e você deve vê-lo pendurar com a mesma freqüência que WaitForExit estava experimentando tempos limite. Da mesma forma, a remoção de chamadas para System. Diagnostics. Process faz com que o problema desapareça, o que implica que é algo a ver com a interação entre os dois.
Os problemas ocorrem em pelo menos cinco dispositivos Android diferentes usando uma variedade de processadores e o Android 4.2.2 e o Android 5.0.1.
Deve-se notar que é improvável que esse hangar seja o problema "esqueceu-se de esvaziar todos os fluxos de buffer", que é uma fonte comum de comportamento de suspensão de processos porque todos os fluxos de entrada e erro são mesclados e os fluxos são lidos para EOF em todos os casos .

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.