Calendário de notícias do mercado forex.
Opções de ações impostos w2.
Outputdatarecepois de esperarforexit.
Instrui o componente Processo a esperar indefinidamente para que o processo associado saia. Nenhum Id de processo foi configurado e um identificador a partir do qual a propriedade Id pode ser determinada depois de não existir. Não existe nenhum processo associado a este objeto Processo. Você está tentando chamar WaitForExit após um processo posterior 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. Deve ser gerado por saída depois de esperar, outros métodos são 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. Este waitforexit causa um aplicativo outputdatareceived parar 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 outputdatareceived gravado em outputdatareceived inserir seu loop de mensagem. Além disso, as versões anteriores não esperaram que os manipuladores de eventos outputdatareceived saíssem se o tempo MaxValue completo fosse atingido. Esta sobrecarga garante 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 do WaitForExit Int32 quando a saída padrão tiver sido redirecionada para manipuladores de eventos assíncronos. Quando um processo associado é encerrado, quando é encerrado pelo sistema de operação através de um sistema de saída de saída anormal 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 outputdatareceived, que inclui o ExitTimeby usando o Handle para o processo encerrado. Como o processo associado foi encerrado, a propriedade Handle do componente no waitforexit 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 alças para processos que não foram lançados pelos componentes do Waitforexit, portanto, ele continua após as informações ExitTime e Waitforexit na memória até o componente Processar, especificamente, liberar 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 nenhum administrativo após o processo. Close libera a memória alocada para o processo finalizado. Consulte a seção Comentários da referência de propriedade StandardError outputdatareceived. Downloads Visual Studio SDKs Software de avaliação Após downloads Recursos do Office Recursos do SharePoint Server Recursos do SQL Server Windows Server waitforexit Programas Visão geral sobre assinaturas Administradores Waitforexit Microsoft Imagine Microsoft Parceiros de estudante ISV Startups Eventos Waitforexit Magazine Fóruns Blogs Canal 9 APIs de documentação e referência. O conteúdo solicitado foi removido. Métodos de Processo de Classe de Processo Método WaitForExit. WaitForExit Método WaitForExit Método. Colapse waitforexit tabela de conteúdo. Esta documentação é arquivada e não está sendo mantida. Versão atual do NET Framework. Condição de Exceção Win32Exception A configuração de espera não pôde ser acessada. LinkDemand para confiança total para o chamador imediato. Este membro não pode ser usado por código parcialmente confiável. NET Framework Disponível desde 1. Esta página é útil? Agradecemos seus comentários. Centros de desenvolvimento Windows Office Visual Studio Microsoft Azure Mais Recursos de aprendizagem Microsoft Virtual Academy Canal 9 MSDN Magazine. Fóruns da comunidade Blogs Codeplex. Programas BizSpark para startups Microsoft Imagine para estudantes.
Pré-carga após o volume do curso da carga e parte de Saída cardíaca 1.
5 pensamentos sobre & ldquo; Outputdatareceived after waitforexit & rdquo;
Desejo escrever tais rimas que não sugiram uma restrição, mas, ao contrário, a mais selvagem liberdade.
Quem emergirá do meio do mar das nações como o sobrevivente e o líder.
A função foi adicionada por Brim e Brackus descobriu sobre seu poder através de Lizel.
Excursão do Patrimônio de Mughal, incluindo os Jardins de Lodhi, o Túmulo de Humayun e o Templo de Akshardham (Reserve Online com a Viator).
As conjunções subordinadas italianas (congiunzioni subordinativas) se juntam a uma cláusula dependente a outra cláusula - denominada a cláusula principal ou independente - que modifica, completa ou aclara seu significado.
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.
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.
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.
para resolver esse problema:
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.
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!
Depois de ler todos os posts aqui, resolvi a solução consolidada de Marko Avlijaš. No entanto, não resolveu todos os meus problemas.
Em nosso ambiente, temos um Serviço do Windows que está programado para executar centenas de diferentes. bat. cmd. exe. etc arquivos que se acumularam ao longo dos anos e foram escritas por muitas pessoas diferentes e em diferentes estilos. Não temos controle sobre a redação dos programas e programas; scripts, somos apenas responsáveis pelo agendamento, execução e relatórios sobre o sucesso / falha.
Então eu tentei praticamente todas as sugestões aqui com diferentes níveis de sucesso. A resposta de Marko foi quase perfeita, mas quando executado como um serviço, ele nem sempre captou stdout. Nunca cheguei ao fundo do porquê não.
processstartinfo pendurado em waitforexit porque.
Eu realmente tenho o próximo código:
info = new System. Diagnostics. ProcessStartInfo ("TheProgram. exe", String. Join ("", args)); info. CreateNoWindow = true; info. WindowStyle = System. Diagnostics. ProcessWindowStyle. Hidden; info. RedirectStandardOutput = true; info. UseShellExecute = false; System. Diagnostics. Process = System. Diagnostics. Process. Start (info); p. WaitForExit (); Console. WriteLine (p. StandardOutput. ReadToEnd ()); // precisa do conteúdo do StandardOutput.
Eu entendo que a saída do método que estou começando é redonda de 7MB de duração. Executá-lo dentro do console do Windows funciona de alta qualidade. Infelizmente, programaticamente, isso trava indefinidamente no WaitForExit. Observe, além disso, que o código não seja compatível com saídas menores (como 3KB).
É imaginável que o StandardOutput interior em ProcessStartInfo não pode armazenar 7MB? Se sim, o que devo fazer como substituto? Caso contrário, o que estou falhando?
7 de novembro de 2016 e middot;
7 de novembro de 2016 e middot;
7 de novembro de 2016 e middot;
O problema é que, para aqueles que redirecionam StandardOutput e / ou StandardError, o buffer interno pode se tornar completo. Qualquer ordem que você empregue, pode haver um problema:
Se você esperar que o processo saia antes de ler StandardOutput, o processo pode bloquear a tentativa de gravar nele, de modo que o processo nunca termine. Se você lê o StandardOutput usando o ReadToEnd, seu processo pode bloquear se o processo nunca fecha o StandardOutput (por exemplo, se ele nunca termina ou se está bloqueado a escrever para o StandardError).
A resposta é usar leituras assíncronas para ter certeza de que o buffer não está cheio. Para evitar quaisquer impasses e acumular todas as saídas de cada StandardOutput e StandardError, faça o seguinte:
EDIT: Veja as soluções abaixo para lidar com o tempo limite e evite as exceções & lt; robust & gt; ObjectDisposeException.
7 de novembro de 2016 & middot;
7 de novembro de 2016 & middot;
7 de novembro de 2016 e middot;
7 de novembro de 2016 e middot;
7 de novembro de 2016 & middot;
A documentação para Process. StandardOutput diz para aprender mais cedo do que você espera diferentemente você vai impasse, trecho copiado abaixo:
// Iniciar o processo filho. Processo p = novo Processo (); // Redirecione o fluxo de saída do processo filho. p. StartInfo. UseShellExecute = false; p. StartInfo. RedirectStandardOutput = true; p. StartInfo. FileName = "Write500Lines. exe"; p. Start (); // Não espere que o processo filho saia antes de // ler até o final do seu fluxo redirecionado. // p. WaitForExit (); // Leia o fluxo de saída primeiro e aguarde. string output = p. StandardOutput. ReadToEnd (); p. WaitForExit ();
7 de novembro de 2016 & middot;
7 de novembro de 2016 & middot;
A resolução de Mark Byers é muito boa, mas eu simplesmente adicionaria o seguinte: os delegados OutputDataReceived e ErrorDataReceived querem se livrar antes que o outputWaitHandle e errorWaitHandle sejam descartados. Se o método continuar a produzir conhecimento após o tempo limite ter sido excedido após o que termina, as variáveis outputWaitHandle e errorWaitHandle provavelmente serão acessadas após serem descartadas.
(Para sua conveniência, acrescentei esta advertência como uma solução, pois não pude tocar em sua apresentação.)
7 de novembro de 2016 e middot;
7 de novembro de 2016 e middot;
7 de novembro de 2016 e middot;
A desvantagem com ObjectDisposedException não processada ocorre enquanto o método é expirado. Nesse caso, as partes opostas da situação:
se (process. WaitForExit (timeout) && outputWaitHandle. WaitOne (tempo limite) && errorWaitHandle. WaitOne (tempo limite))
não é feito. Eu resolvi esse lado negativo da seguinte maneira:
1 de janeiro de 1970 e middot;
Nós temos esse fator de forma inteligente (ou uma versão).
1) Adicione um tempo limite para p. WaitForExit (nnnn); o lugar nnnn está em milissegundos.
2) Coloque o nome ReadToEnd mais cedo que a chamada WaitForExit. Isto é o que vimos no conselho da MS.
1 de janeiro de 1970 & middot;
Uma palavra de advertência com a resolução de Mark Byers:
7 de novembro de 2016 e middot;
7 de novembro de 2016 e middot;
Rob falou de volta e me armazenou algumas horas extras de testes. Leia o buffer de saída / erros mais cedo do que pronto:
// Leia o fluxo de saída primeiro e depois wait. string output = p. StandardOutput. ReadToEnd (); p. WaitForExit ();
1 de janeiro de 1970 & middot;
Eu resolvi desta forma:
Process proc = new Process (); proc. StartInfo. FileName = batchFile; Proc. StartInfo. UseShellExecute = false; proc. StartInfo. CreateNoWindow = true; proc. StartInfo. RedirectStandardError = true; Proc. StartInfo. RedirectStandardInput = true; proc. StartInfo. RedirectStandardOutput = true; Proc. StartInfo. WindowStyle = ProcessWindowStyle. Hidden; Proc. Start (); StreamWriter streamWriter = proc. StandardInput; StreamReader outputReader = proc. StandardOutput; StreamReader errorReader = proc. StandardError; enquanto (! outputReader. EndOfStream) enquanto (! errorReader. EndOfStream) streamWriter. Close (); proc. WaitForExit ();
Eu redirecionasse cada entrada, saída e erro e tratava o estudo de saída e fluxos de erro. Esta resposta funciona para o SDK 7- eight.1, tanto para o Windows 7 como para o Windows 8.
1 de janeiro de 1970 & middot;
Eu fator que é um método discreto e mais alto (nós não estamos procurando AutoResetEvent):
7 de novembro de 2016 e middot;
7 de novembro de 2016 e middot;
Eu já tive uma questão semelhante, no entanto, o raciocínio era diferente. Por outro lado, ocorreria no Windows 8, mas agora não está no Windows 7. A seguinte linha acabou por ter levado ao problema.
A resposta foi uma vez para NÃO desativar o UseShellExecute. Agora recebi uma janela popup do Shell, que é indesejável, no entanto, é significativamente melhor do que esse sistema, esperando que nada seja explícito. Então eu adicionei o próximo trabalho para isso:
Agora, o que me incomoda é o motivo pelo qual isso está acontecendo abaixo do Windows oito na posição principal.
7 de novembro de 2016 e middot;
Isso publica, talvez antigo, no entanto, eu considerei o princípio, porque ele regularmente pendura é devido ao excesso de pilha para a saída redirectStandardout ou no caso de você ter redirecionadoStandarderror.
Como as informações de saída ou os dados de erro são enormes, isso levará a um tempo de espera porque ele continua a ser processado por período indefinido.
Como usar System. Diagnostics. Process corretamente.
Eu vi muitas perguntas no stackoverflow e em outros lugares sobre a execução de um processo e a captura da saída. Usar o System. Diagnostics. Process corretamente não é fácil e, na maioria das vezes, ele está errado.
Alguns erros comuns com System. Diagnostics. Process:
Não capturar os dois fluxos de saída (erro e saída) Não redirecionar a entrada pode fazer com que os aplicativos travem Não fechar entrada redirecionada pode fazer com que os aplicativos travem Não chamar BeginOutputReadLine / BeginErrorReadLine ao usar eventos Usar OutputDataReceived / ErrorDataReceived sem aguardar null Não verificar null em OutputDataReceived / ErrorDataReceived handlers Esquecendo de setar EnableRaisingEvents = true; ao usar o evento Exitado, esquecer as configurações de ErrorDialog, CreateNoWindow ou UseShellExecute Manipulação incorreta dos leitores de fluxo StandardOutput ou StandardError.
Então, com isso disse, aqui estão algumas diretrizes básicas:
Use os eventos OutputDataReceived / ErrorDataRecieved NOT, StandardOutput ou StandardError. Isso irá poupar-lhe muita dor de cabeça e gerenciamento de threads desnecessário. Sempre capture todas as saídas E entradas, se você não planeja fornecer entrada, feche o fluxo imediatamente. Seu processo não é feito até que ele tenha saído E você leu todos os dados. OutputDataReceived CAN AND SERÁ disparado após uma chamada para WaitForExit () retorna. Você precisará de alças de espera para cada fluxo de saída e defina o controle de espera depois de receber os dados de recebimento (nulo).
No comments:
Post a Comment