Saída padrão do processo waitforexit

Processo da saída padrão waitforexit
Obter através da App Store Leia esta publicação em nosso aplicativo!
Saída do processo de redirecionamento C #
Gostaria de redirecionar a saída padrão do Processo para uma string para análise posterior. Gostaria também de ver a saída na tela, enquanto o processo está em execução, e não apenas quando ela termina.
É mesmo possível?
Exemplo de MSDN:
Veja também OutputDataReceived e BeginOutputReadLine () para uma alternativa para ReadToEnd (), que melhorará o seu requisito de "ver saída enquanto o processo estiver em execução".
Se você deseja executar um exe do seu aplicativo c # e obter o resultado dele, então você pode usar o código abaixo.

Processo da saída padrão waitforexit
Obter através da App Store Leia esta publicação em nosso aplicativo!
c # ProcessStartInfo. Start - leitura de saída, mas com tempo limite.
Se você quiser iniciar outro processo e aguardar (com tempo limite) para terminar, você pode usar o seguinte (do MSDN).
Se você quiser iniciar outro processo e ler sua saída, então você pode usar o seguinte padrão (de SO)
Como você pode combinar os dois para ler todas as entradas, não ficar preso no impasse e ter um tempo limite se o processo em execução for errado?
Essa técnica irá pendurar se o buffer de saída for preenchido com mais de 4 KB de dados. Um método mais infalível é registrar os delegados para serem notificados quando algo é escrito no fluxo de saída. Eu já sugeri este método antes em outro post:
Você não precisa combinar os dois - a classe Processo tem um evento que dispara quando a saída é enviada para o StandardOutput - OutputDataReceived.
Se você se inscrever no evento, você poderá ler o resultado conforme ele chega e, no seu ciclo de programa principal, você ainda pode perder tempo.
Você pode tentar modificar o primeiro método para algo assim.
Você também pode usar o APM, assim:
Defina um delegado para a chamada ReadToEnd:
Em seguida, use o delegado para chamar o método como este:
EDITAR: tratamento de erros removido por clareza.
Basta adicionar tudo do primeiro exemplo abaixo da chamada WaitForExit () ao segundo exemplo.

Processo da saída padrão 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 :)

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.