C # processo waitforexit saída padrão

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

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.

Processo C # espera a saída padrão padrão
existe um erro no seguinte código no seu programa:
Se o processo filho tentar escrever mais para stdout e / ou stderr do que caberá no outputReader e / ou no ErrorReader, ele ficará pendurado até que seu programa leia algumas dessas saídas. Mas o seu programa está aguardando até que o processo seja concluído antes de ler qualquer coisa. Então você tem um impasse.
Meu Java está enferrujado, e eu estava procurando uma resposta para um problema diferente, mas ocorreu-me que talvez o seguinte comentário de.
pode ser relevante para o seu problema:
Eu baixei a fonte e compilei diretamente sem modificar o código e iniciar para testar e parece funcionar bem, mas apenas para algum executável.
Eu disse apenas porque desenvolvi um aplicativo no ano passado para produzir ferramentas de desfragmentação do auslogics chamado "cdefrag. exe" e a saída nunca é completa, e o problema com sua aplicação é exatamente o mesmo.
Estou tendo o mesmo problema que muitos aqui: como usar ftp. exe ou qualquer exe de shell bidirecional.
Estou usando plink. exe: preciso na caixa de texto para obter saída em tempo real: não apenas "outputreader. readtoend".
Claro que eu removi o "processo de espera para sair". Eu tentei colocar uma ReadLine em vez de readtoend. mas sem sorte. Eu até tentei um loop "while".
Eu e nós, no fórum, precisamos disso:
1- nenhuma janela do console é mostrada.
2- seja capaz de ver em tempo real, que linha por linha o que é a saída do comando (exemplo ftp sdf @ sdf pedirá senha, precisamos ver isso na caixa, não esperando que o ftp. exe seja Parou manualmente e depois mostra a saída ".
Eu sei que isso é possível, um cara fez o securetunnel um pequeno programa gratuito no delphi que captura a saída de um shell exe e imprime em tempo real em uma caixa de texto, então o programa pode responder com entradas no momento certo (como quando o shell solicita uma senha).
alguma idéia de como fazer isso?
Estou executando a partir do cmd é openvpn --config client. ovpn --ca certificate. cer --auth-user-pass user. txt.
Eu não quero passar o arquivo user. txt e insira o nome de usuário e a senha do aplicativo. Já manipulei a saída usando o manipulador. Na edição quando o usuário deseja sair, eu quero inserir F4, pois essa é a chave para sair do openvpn de forma limpa.
Não consigo descobrir como lidar com a entrada e a saída, ambos ao mesmo tempo. Eu acho que também preciso testar no manipulador de saída para texto como "Enter Esername:" e depois passar pelo nome de usuário via swriter.
processInfo = novo ProcessStartInfo (comando "cmd. exe", "/ C" +);
sb = novo StringBuilder ();
process. OutputDataReceived + = new DataReceivedEventHandler (Process_OutputDataReceived);
Quero transmitir a entrada para um arquivo exe sem usar o arquivo físico. Para fazer o mesmo que o seguinte comando, digite blabla. txt | abc. exe. Por exemplo. O conteúdo do blabla. txt já está em uma variável e eu quero passar o conteúdo da variável para abc. exe.
Agradecemos antecipadamente a sua resposta.
Digite seu nome: Myname.
Seu nome é: Myname.
Digite seu nome: seu nome é:
ps. StartInfo. FileName = "& lt; my exe name & gt;"
ps. StartInfo. Arguments = "& lt; argumentos da linha de comando & gt;"
Dim st As New System. Text. StringBuilder (sr_Ps. ReadToEnd ())
exe c: \ abc. txt & lt; xyz. txt.
Como eu posso fazer isso.
Eu preciso redirecionar o conteúdo de 1 arquivo para o aplicativo exe.
Isso pode ajudá-lo.
Por algum motivo, ele trava na leitura de entrada padrão.
Alguém pode me explicar o porquê.
Por que isso faz isso, eu não sei. ainda, mas se alguém tiver pensado em pegar o prompt quando seu processo está aguardando entrada, ficaria feliz em ouvi-lo.
Existem 10 tipos de pessoas no mundo.
Aqueles que entendem o binário e aqueles que não o fazem.
No meu aplicativo, eu preciso simular a entrada padrão com os parâmetros tirados do código c #.
Como eu posso fazer isso?
Web03 | 2.8.171231.1 | Última atualização 27 de abril de 2007.
Tudo o resto Copyright & copy; CodeProject, 1999-2017.

VBlog Lucian & # 039; s VBlog Lucian & # 039; s VBlog.
Às vezes, você deseja iniciar um utilitário externo e enviar a entrada e também capturar sua saída. Mas é fácil entrar no impasse assim.
Usando p As New System. Diagnostics. Process.
p. StandardInput. Write ("world" e amp; vbCrLf & amp; "hello")
'deadlock aqui se p precisa escrever mais de 12k para StandardOutput.
Dim op = p. StandardOutput. ReadToEnd ()
Console. WriteLine ("OUTPUT:"): Console. WriteLine (op)
O impasse neste caso surge porque "cat" (um utilitário Unix padrão) lê primeiro de StandardInput e, em seguida, grava em StandardOutput, depois lê novamente e assim por diante até que não haja nada a ser lido. Mas se o StandardOutput preencher com ninguém para lê-lo, não pode mais escrever e bloquear.
O número "12k" é arbitrário e não confio nisso.
Usando p As New System. Diagnostics. Process.
'deadlock aqui se p precisa escrever mais de 12k para o StandardError.
Dim op = p. StandardOutput. ReadToEnd ()
Dim err = p. StandardError. ReadToEnd ()
Console. WriteLine ("OUTPUT:"): Console. WriteLine (op)
Console. WriteLine ("ERROR:"): Console. WriteLine (err)
A documentação do MSDN diz: "Você pode usar operações de leitura assíncronas para evitar essas dependências e seu potencial de bloqueio. Alternativamente, você pode evitar a condição de impasse, criando dois tópicos e lendo a saída de cada fluxo em um segmento separado." Então, é isso que nós 'Eu vou fazer.
Usando threads para redirecionar sem deadlock.
'BOM CÓDIGO: isso não será impasse.
Usando p Como Novo Diagnóstico. Processo.
"NÃO WaitForExit ainda, uma vez que isso iria introduzir deadlocks.
p. InputAndOutputToEnd ("world" & amp; vbCrLf & amp; "hello", op, Nothing)
Console. WriteLine ("OUTPUT:"): Console. WriteLine (op)
'' 'InputAndOutputToEnd: uma maneira prática de usar entrada / saída / erro redirecionado em uma p.
'' '& lt; param name = "p" & gt; O p para redirecionar. Deve ter UseShellExecute configurado como falso. & Lt; / param & gt;
'' '& lt; param name = "StandardInput" & gt; Essa string será enviada como entrada para a p. (deve ser Nothing if not StartInfo. RedirectStandardInput) & lt; / param & gt;
'' '& lt; param name = "StandardOutput" & gt; A saída do p será coletada nesta string ByRef. (deve ser Nothing if not StartInfo. RedirectStandardOutput) & lt; / param & gt;
'' '& lt; param name = "StandardError" & gt; O erro do p será coletado nesta string ByRef. (deve ser Nothing if not StartInfo. RedirectStandardError) & lt; / param & gt;
'' '& lt; remarks & gt; Esta função resolve o problema de deadlock mencionado em msdn. microsoft/en-us/library/system. diagnostics. p.standardoutput. aspx</remarks>
& lt; RuntimepilerServices. Extension () & gt; Sub InputAndOutputToEnd (ByVal p como Diagnostics. Process, ByVal StandardInput As String, ByRef StandardOutput como String, ByRef StandardError As String)
Se p is Nothing, então, lance New ArgumentException ("p não deve ser nulo")
"Suponha que p tenha começado. Infelizmente, não há como verificar.
Se p. StartInfo. UseShellExecute, então, lança New ArgumentException ("Set StartInfo. UseShellExecute to false")
Se (p. StartInfo. RedirectStandardInput & lt; & gt; (StandardInput isNot Nothing)), então, lança New ArgumentException ("Forneça uma entrada não nula somente quando StartInfo. RedirectStandardInput")
Se (p. StartInfo. RedirectStandardOutput & lt; & gt; (StandardOutput IsNot Nothing)), então, lance New ArgumentException ("Forneça uma saída não nula somente quando StartInfo. RedirectStandardOutput")
Se (p. StartInfo. RedirectStandardError & lt; & gt; (StandardError IsNot Nothing)), então, lança Nova ArgumentException ("Fornecer um erro não nulo somente quando StartInfo. RedirectStandardError")
Dim outputData As New InputAndOutputToEndData.
Dim errorData As New InputAndOutputToEndData.
Se p. StartInfo. RedirectStandardOutput então.
outputData. Thread = New Threading. Thread (AddressOf InputAndOutputToEndProc)
Se p. StartInfo. RedirectStandardError então.
errorData. Thread = New Threading. Thread (AddressOf InputAndOutputToEndProc)
Se p. StartInfo. RedirectStandardInput então.
Se p. StartInfo. RedirectStandardOutput, então outputData. Thread. Join (): StandardOutput = outputData. Output.
Se p. StartInfo. RedirectStandardError Then errorData. Thread. Join (): StandardError = errorData. Output.
Se outputData. Exception IsNot Nothing, então, lance OutputData. Exception.
Se errorData. Exception IsNot Nothing Then Throw errorData. Exception.
Private Class InputAndOutputToEndData.
Tópico público como Threading. Thread.
Stream público como IO. StreamReader.
Public Output As String.
Exceção pública como exceção.
Private Sub InputAndOutputToEndProc (ByVal data_ As Object)
Dim data = DirectCast (data_, InputAndOutputToEndData)
Tente: data. Output = data. Stream. ReadToEnd: Catch e As Exception: data. Exception = e: End Try.
Cancelar resposta.
Por que não usaria process. OutputDataReceived e process. ErrorDataReceived?
Dessa forma, você pode ecoar (ou capturar) a saída de ambos na ordem recebida.
Isso parece muito mais simples do que assíncrono ou se encadeia.

Processo C # espera a saída padrão padrão
No seu construtor ProcessCaller você está passando o formulário (este) como o alvo.
e se a função StartProcess não estiver em um formulário, o que devo passar no construtor?
Estou guardando o stdoutput para um arquivo de texto.
Obrigado pelo código! Me salvou um pouco de tempo, pois era exatamente assim que planejava fazer esse controle.
2. A única função exportada "Executar" nesta DLL usa a mesma convenção de chamada que todas as DLLs do Windows. (WINAPI = __stdcall)
3. Você pode usar esta DLL em qualquer compilador para qualquer linguagem de programação que suporte chamadas de API. (Se você pode chamar Kernel32.dll, você também pode chamar CaptureConsole. dll)
4. Este download contém uma Demo Application para C ++, Visual Basic 6, VB e C #, que demonstram como carregar a DLL e chamar a função "Execute".
5. A DLL é thread-safe: você pode executar múltiplas aplicações de console ao mesmo tempo a partir de diferentes threads.
6. Você pode escolher se deseja stdout e stderr separados ou como saída mista.
7. O Código de Saída do Console Application é retornado ao chamador.
8. Você pode definir o Diretório de Trabalho (GetCurrentDirectory) para o aplicativo de console.
9. Você pode passar variáveis ​​de ambiente adicionais (GetEnvironmentVariable) para o Console Application ou substituir as existentes.
10. A DLL pode ser compilada como Unicode (exportações ExecuteW) ou ANSI (exporta ExecuteA).
11. A DLL é um projeto MFC C ++, mas nenhum MFCxx. DLL externo é necessário porque o MFC está vinculado de forma estática. (CaptureConsole. DLL depende apenas de DLLs padrão do Windows)
12. A DLL usa internamente CStrings e exporta BSTR, portanto, um estouro de buffer é impossível. Se o seu console imprimir 50 MB de saída de texto, isso não é problema.
13. Todos os erros da API que podem acontecer ao iniciar o processo do Console são tratados e retornados como uma mensagem de erro legível para humanos.
14. Você pode especificar um tempo limite opcional. Se isso acontecer, o processo da consola será morto. Isso evita que processos mortos se arrastem quando usados ​​em um servidor.
15. Caracteres especiais (como äöüáéú) são convertidos para a página de códigos DOS quando passados ​​como parâmetros de linha de comando.
16. Os caracteres especiais são convertidos de volta para a página de códigos ANSI quando retornados ao aplicativo de chamada.
Eu tenho um problema que eu não consigo resolver - como faço para suspender o tópico?
Por exemplo, na sua amostra, se quisermos adicionar um botão que irá pausar a impressão e retomá-la com outro clique do botão. Como pode ser feito?
Eu não sei se esse tópico ainda está aberto, mas eu tenho algumas perguntas.
Como você pode encerrar o processo imediatamente, um erro padrão é lido?
Estou tentando modificar o código para executar um arquivo em lotes contendo alguns comandos, mas eu quero que o processo seja encerrado a qualquer momento que o stdErr seja encontrado.
Agradeceria alguma ajuda.
Com seu aplicativo de demonstração que grava no console (SmallConsoleProgram. exe), tudo funciona bem.
O Mplex é um multiplexador que multiplexa um arquivo MPEG de arquivos de áudio e vídeo separados.
Mplex escreve toda a sua saída para o console.
Imediatamente depois que o Mplex começou, ele escreve a primeira linha de saída para a caixa do DOS, que é sempre esta:
A caixa de texto fica vazia o tempo todo.
Não antes do processo Mplex sair de TODOS, a saída aparece de uma só vez!
Se encontrou outro projeto que faz o mesmo, mas escrito em C ++.
Ele também exibe a saída APÓS o Mplex terminar!
Mas tenho más notícias para todos aqueles que têm o mesmo problema:
Não consegue redirecionar a saída do console de aplicativos C ++!
Em vez de admitir um erro no MSDN, eles deveriam ter resolvido o problema!
O artigo da base de conhecimento é de 2003!
Deve haver um auto-descarga depois de cada linha que foi impressa, então TODOS os aplicativos do console podem ser monitorados!
Web01 | 2.8.171231.1 | Última Atualização 1 de setembro de 2003.
Tudo o resto Copyright & copy; CodeProject, 1999-2017.