C # useshelexecute waitforexit

C # UseShellExecute = TRUE.

processInfo = new ProcessStartInfo (& quot; cmd. exe & quot;);

processInfo. UseShellExecut e = true;

processInfo. WorkingDirecto ry = @ & quot; C: \ Windows \ System32 & quot ;;

processInfo. RedirectStanda rdError = false;

processInfo. RedirectStanda rdOutput = false;

processInfo. RedirectStanda rdInput = false;

processInfo. Arguments = & quot; schtasks / run / s server_name batname. bat & quot ;;

Facebook Twitter LinkedIn especialistas-troca / perguntas / 28944964 / C-UseShellExecute-TRUE. html cópia.

cyimxtck (7 comentários)

Que então usará o UAC para elevar os privilégios. Você também pode precisar incorporar um manifesto de aplicativo:

Produz a seguinte saída - Sem a propriedade Verb para & quot; runas & quot; Eu recebo: - saige-

shell (schtasks / run / s server_name batname. bat)

A nova geração de ferramentas de gerenciamento de projetos.

Com a ferramenta de gerenciamento de projetos de segunda-feira, você pode ver o que todos em sua equipe estão trabalhando em um único piscar de olhos. Seus painéis intuitivos são personalizáveis, para que você possa criar sistemas que funcionem para você.

Mas pode ser mais benéfico usar a API do Agendador de Tarefas. Bart De Smet tem uma extensa write-up sobre o assunto aqui:

Exemplo de uso.

Eu resolvi assim:

Eu redirecionei tanto a entrada, saída e erro e lidou com a leitura de fluxos de saída e erro. Essa solução funciona para o SDK 7- 8,1, tanto para o Windows 7 quanto para o Windows 8.

Eu tentei fazer uma classe que resolveria seu problema usando leitura de fluxo assíncrona, levando em consideração Mark Byers, Rob, stevejay respostas. Ao fazer isso, percebi que há um bug relacionado à leitura do fluxo de saída do processo assíncrono.

Você não pode fazer isso:

Você receberá System. InvalidOperationException: StandardOut não foi redirecionado ou o processo ainda não foi iniciado.

Então você precisa iniciar a leitura assíncrona 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 defini-los como assíncronos:

Então, algumas pessoas podem dizer que você só precisa ler o fluxo antes de defini-lo como assíncrono. Mas o mesmo problema ocorre. Haverá uma condição de corrida entre a leitura síncrona e o fluxo em modo assíncrono.

Não há como obter uma leitura assíncrona segura de um fluxo de saída de um processo na maneira real como "Process" e "ProcessStartInfo" foram projetados.

Provavelmente, é melhor usar a leitura assíncrona, como sugerido por outros usuários para o seu caso. Mas você deve estar ciente de que pode perder alguma informação 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 descartada (tentei as "soluções" das outras respostas).

Então decidi sugerir outra solução:

Este código depurado e funciona perfeitamente.

Introdução.

A resposta aceita atualmente não funciona (gera exceção) e há muitas soluções alternativas, mas nenhum código completo. Isto é, 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 o código completo com base em como eu quero usar o método Process. Start.

Eu usei-o para criar um diálogo de progresso em torno dos comandos do git. É assim que eu usei:

Em teoria, você também pode combinar stdout e stderr, mas eu não testei isso.

As outras soluções (incluindo EM0s) ainda estão em deadlock para meu aplicativo, devido a tempos limite internos e ao uso de StandardOutput e StandardError pelo aplicativo gerado. Aqui está o que funcionou para mim:

Editar: adicionada inicialização do StartInfo ao exemplo de código.

Este post talvez desatualizado, mas eu descobri a causa principal porque normalmente travar é devido ao estouro de pilha para a saída redirectStandard ou se você tiver redirectStandarderror.

Como os dados de saída ou os dados de erro são grandes, isso causará um tempo de interrupção, pois ainda está sendo processado por duração indefinida.

então, para resolver esse problema:

Eu acho que essa é uma abordagem simples e melhor (não precisamos do AutoResetEvent):

Eu estava tendo o mesmo problema, mas o motivo era diferente. No entanto, isso aconteceria no Windows 8, mas não no Windows 7. A linha a seguir parece ter causado o problema.

A solução foi NÃO desabilitar o UseShellExecute. Eu agora recebi uma janela popup do Shell, que é indesejada, mas muito melhor do que o programa esperando que nada de especial aconteça. Então eu adicionei a seguinte solução para isso:

Agora, a única coisa que me incomoda é por que isso está acontecendo no Windows 8 em primeiro lugar.

Eu sei que esta é a ceia de idade, mas, depois de ler esta página inteira, nenhuma das soluções estava funcionando para mim, embora eu não tenha tentado Muhammad Rehan como o código foi 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, eu acho que é algo a ver com o comprimento da saída antes de uma marca EOF.

De qualquer forma, a solução que funcionou para mim foi 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, isso não resolveu todos os meus problemas.

Em nosso ambiente, temos um serviço do Windows que está programado para executar centenas de arquivos. bat. cmd. exe diferentes. etc arquivos que se acumularam ao longo dos anos e foram escritos por muitas pessoas diferentes e em diferentes estilos. Nós não temos controle sobre a escrita dos programas & amp; scripts, somos responsáveis apenas pelo agendamento, execução e geração de relatórios sobre 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 executada como um serviço, nem sempre captava stdout. Eu nunca cheguei ao fundo do por que não.

C # Hoje.

Vamos C # hoje!

Como evitar deadlocks ao ler o console filho redirecionado em C # 2.

A leitura de saída secundária redirecionada parece ser uma tarefa fácil. Mas há desenvolvedores que lutam com o processo filho interrompido devido a deadlocks de gravação / leitura do console. E deadlocks nunca são fáceis de investigar.

Vamos considerar um exemplo comum: um processo pai inicia um processo filho e lê toda a sua saída. Aqui está um exemplo de aplicativo que pode simular o cenário.

O aplicativo pode ser executado em dois modos:

Processo pai - executa o processo filho e lê seu processo filho de saída - imprime alguma saída.

Tudo funciona bem, mas vamos considerar um cenário em que a saída da criança tenha um significado maior.

Desta vez, o processo pai será interrompido - é um impasse. Por quê? Vamos pensar no que os pais fazem - primeiro configurar o redirecionamento de saída do processo filho.

Em seguida, inicia o processo filho.

Etapa consecutiva está aguardando a conclusão do processo filho.

E esse é o ponto em que o processo pai fica comprometido com o filho. Por quê? O pai está esperando que o filho termine e o filho também tem alguma dependência do pai.

Primeiro, você precisa entender como o redirecionamento de saída funciona. Existe um buffer criado para a saída. Quando a criança está escrevendo para o console, está gravando no buffer. Se o filho escreve muito, o buffer pode ficar cheio. Nesse caso, o filho trava no Console. Grave até que o buffer ganhe algum espaço.

O pai deve ler a saída filho antes de esperar que o filho termine. Então, para consertar o impasse, temos que trocar as linhas seguintes.

O código pai completo deve se parecer abaixo.

Por favor, note que exatamente o mesmo problema pode acontecer com a saída de erro padrão (stderr). Além disso, um impasse semelhante pode ocorrer com a gravação na entrada padrão da criança.

Basicamente, você precisa ser muito cuidadoso e entender o que você está fazendo se você quiser ler a entrada / saída da criança de forma síncrona.

Deixe um comentário Cancelar resposta.

2 pensamentos sobre & ldquo; Como evitar deadlocks ao ler o console filho redirecionado em C # & rdquo;

Não ganharia ainda o impasse se o processo produz muito em stderr? Eu acho que para ser realmente seguro você tem que usar os eventos em vez disso.

Correto, adicionei uma observação sobre o stderr.

Concordo que o manejo assíncrono é uma maneira mais segura. Eu vou escrever um post sobre isso também.

Propriedade ProcessStartInfo. UseShellExecute.

A documentação de referência da API tem uma nova casa. Visite o Navegador da API em docs. microsoft para ver a nova experiência.

Obtém ou define um valor indicando se deve usar o shell do sistema operacional para iniciar o processo.

Assembly: System (no System. dll)

Valor da propriedade.

true se o shell deve ser usado ao iniciar o processo; false se o processo deve ser criado diretamente do arquivo executável. O padrão é verdadeiro .

Configurar essa propriedade como false permite redirecionar fluxos de entrada, saída e erro.

UseShellExecute deve ser false se a propriedade UserName não for nula ou uma string vazia, ou uma InvalidOperationException será lançada quando o processo. Start (ProcessStartInfo) método é chamado.

Quando você usa o shell do sistema operacional para iniciar processos, é possível iniciar qualquer documento (que é qualquer tipo de arquivo registrado associado a um executável que tenha uma ação aberta padrão) e executar operações no arquivo, como impressão, usando o objeto Process. . Quando UseShellExecute é false, você pode iniciar somente executáveis usando o objeto Process.

UseShellExecute deve ser true se você definir a propriedade ErrorDialog como true.

A propriedade WorkingDirectory se comporta de maneira diferente dependendo do valor da propriedade UseShellExecute. Quando UseShellExecute é true, a propriedade WorkingDirectory especifica o local do executável. Se WorkingDirectory for uma string vazia, presume-se que o diretório atual contenha o executável.

Quando UseShellExecute é false, a propriedade WorkingDirectory não é usada para localizar o executável. Em vez disso, ele é usado apenas pelo processo que é iniciado e tem significado apenas dentro do contexto do novo processo. Quando UseShellExecute é false, a propriedade FileName pode ser um caminho completo para o executável ou um nome executável simples que o sistema tentará localizar nas pastas especificadas pela variável de ambiente PATH.

Proprietà ProcessStartInfo. UseShellExecute.

Data de publicação: ottobre 2016.

Ottiene o imposta un valore che indica se for o shell do sistema operacional para avviare il processo.

Assembly: System (no System. dll)

Valore proprietà.

verdadeiro se o escudo deve ser usado todo o processo; false se ele deve ser criado diretamente por dal file eseguibile. O valor padrão é verdadeiro.

Configurar essa propriedade como false permite redirecionar fluxos de entrada, saída e erro.

P: System. Diagnostics. ProcessStartInfo. UseShellExecute deve ser false se a propriedade P: System. Diagnostics. ProcessStartInfo. UserName não for nula ou uma seqüência vazia, ou uma T: System. InvalidOperationException será lançada quando o M: System. Diagnostics. O método Process. Start (System. Diagnostics. ProcessStartInfo) é chamado.

Quando você usa o shell do sistema operacional para iniciar processos, você pode iniciar qualquer documento (que é qualquer tipo de arquivo registrado associado a um executável que tenha uma ação aberta padrão) e executar operações no arquivo, como impressão, usando o T: Objeto System. Diagnostics. Process. Quando P: System. Diagnostics. ProcessStartInfo. UseShellExecute é false, você pode iniciar somente executáveis usando o objeto T: System. Diagnostics. Process.