Waitforexit c # example

Waitforexit c # example
Eu tenho trabalhado no meu projeto da empresa. Eu notei esse problema, quando eu chamo de um Exe para outro Exe. Durante o arrasto do formulário no segundo Exe, ele mostrará vários formulários. Eu estou usando WaitforExit ().
por favor resolva.
Esta é exatamente a causa do problema. Se WaitForExit é chamado do thread do formulário, ele impedirá que o formulário seja redesenhado. Arrastar algo na frente de uma janela bloqueada deixa um rastro da janela arrastada.
Sugerido como Resposta ahmedilyas Moderador quinta-feira, 28 de julho de 2011 10:34 Marcado como Resposta Jackie-Sun Moderador segunda-feira, 8 de agosto de 2011 6:50.
O código seria melhor e também seria melhor se você pudesse nos dizer exatamente o que está tentando alcançar.
O WaitForExit () simplesmente espera (bloqueia seu código por este período) para um processo sair antes de continuar com a execução do seu código de chamada.
C # MVP (2007-2010) MS Vendor - MS Todo o caminho! Seguidor desde 1995 MS Super Evangelist | Moderador dos fóruns do MSDN.
Sugerido como Resposta ahmedilyas Moderador quinta-feira, 28 de julho de 2011 10:33 Marcado como Resposta Jackie-Sun Moderador segunda-feira, 8 de agosto de 2011 6:50.
Todas as respostas.
O código seria melhor e também seria melhor se você pudesse nos dizer exatamente o que está tentando alcançar.
O WaitForExit () simplesmente espera (bloqueia seu código por este período) para um processo sair antes de continuar com a execução do seu código de chamada.
C # MVP (2007-2010) MS Vendor - MS Todo o caminho! Seguidor desde 1995 MS Super Evangelist | Moderador dos fóruns do MSDN.
Sugerido como Resposta ahmedilyas Moderador quinta-feira, 28 de julho de 2011 10:33 Marcado como Resposta Jackie-Sun Moderador segunda-feira, 8 de agosto de 2011 6:50.
Eu tinha check. it tem problema em waitforexit () only. i notei que o problema ao mover segundo formulário exe.
o que exatamente é o problema? você leu minha resposta? você também leu o link que eu havia fornecido?
WaitForExit () é um método de bloqueio de threads que fará exatamente isso - espere que um processo saia antes que ele continue com seu código. ele NÃO fará com que seu formulário seja ocultado ou minimizado, a menos que você diga ao seu código para fazer isso antes de chamar WaitForExit ()
C # MVP (2007-2010) MS Vendor - MS Todo o caminho! Seguidor desde 1995 MS Super Evangelist | Moderador dos fóruns do MSDN.
Tudo está funcionando bem. mas quando eu movo o formulário, ele mostra várias formas.
Esta é exatamente a causa do problema. Se WaitForExit é chamado do thread do formulário, ele impedirá que o formulário seja redesenhado. Arrastar algo na frente de uma janela bloqueada deixa um rastro da janela arrastada.
Sugerido como Resposta ahmedilyas Moderador quinta-feira, 28 de julho de 2011 10:34 Marcado como Resposta Jackie-Sun Moderador segunda-feira, 8 de agosto de 2011 6:50.
quando você diz mostrando vários formulários - você está falando sobre várias instâncias dos formulários ou apenas o desenho / renderização?
se for o desenho / renderização, então sim, como foi dito antes - é porque ele está esperando o processo sair / terminar antes de continuar e é threadblocking, então você verá o problema & quot; problem & quot; você está parecendo estar descrevendo. Não há & quot; corrigir & quot; por isso, como não é um bug ou um problema, mas apenas o que você está usando e como você está usando.
Existe uma razão pela qual você está usando WaitForExit ()? Você tem que mostrar seu formulário quando você está usando WaitForExit ()? Por que você não esconde ou minimiza o formulário antes de chamar WaitForExit () e restaurá-lo depois?
C # MVP (2007-2010) MS Vendor - MS Todo o caminho! Seguidor desde 1995 MS Super Evangelist | Moderador dos fóruns do MSDN.

Waitforexit c # example
Eu acho que você só quer isso:
Veja a página do MSDN para o método. Ele também tem uma sobrecarga onde você pode especificar o tempo limite, então você não está esperando potencialmente para sempre.
Use Process. WaitForExit? Ou assine o evento Process. Exited se não quiser bloquear? Se isso não fizer o que você deseja, forneça mais informações sobre suas necessidades.
Eu faço o seguinte na minha candidatura:
Existem alguns recursos extras que você pode achar úteis.
Você pode usar a espera para sair ou você pode pegar a propriedade HasExited e atualizar sua interface do usuário para manter o usuário "informado" (gerenciamento de expectativa):

Waitforexit c # example
Então eu tenho lutado contra esse problema por algum tempo e tentei muitas maneiras diferentes de consertá-lo, mas não consegui.
Bascally que meu aplicativo faz é chama um arquivo java para carregar um aplicativo em um dispositivo. Enquanto ele está carregando, ele está imprimindo para uma caixa richtext, então eu gostaria de passar para o próximo arquivo. O problema que estou tendo é que enquanto o primeiro arquivo está sendo carregado, o segundo tenta carregar quais problemas de casos. Eu tentei a espera pela saída, mas se eu fizer isso, os dados de saída não serão gravados na caixa rich text. Alguma ideia?
Eu tentei colocar a espera pela saída em muitos lugares diferentes, mas parece que não funciona.
Dois métodos abaixo escrevem o stdout ou erro para o campo richtext.
Qualquer ideia seria ótima. Bascally eu preciso do processo para sair, então eu posso continuar pensando o forloop para carregar o próximo arquivo.
Se você WaitForExit, seu aplicativo bloqueia (aguarda) até que o processo saia. Isso significa que não é possível processar nenhuma mensagem do Windows em seu thread da interface do usuário, portanto, ela não atualiza a interface do usuário.
Você precisa iniciar o processo "em segundo plano" para que sua interface do usuário continue sendo atualizada. Isso pode ser feito com:
Inicie e monitore o processo a partir de um thread separado e passe as informações de progresso de volta ao thread de interface do usuário para exibir Incluir um manipulador de eventos no evento de saída do processo ou periodicamente pesquisar o flag de process. HasExited e use isso para saber quando o primeiro processo acabado. Seu manipulador de eventos iniciaria esse processo e retornaria ao loop principal do aplicativo para que ele fosse executado normalmente enquanto aguardava a conclusão do processo externo.
Sente-se em um loop de espera ocupada até que seja concluído e processe os eventos do aplicativo. (Cuidado com isso, como qualquer evento que cause chamadas reentrantes para este código pode fazer coisas muito ruins. Geralmente, se você usar essa abordagem, você precisará certificar-se de que o resto do seu aplicativo está "bloqueado" em um estado onde ele saiba está ocupado esperando que um processo seja concluído). Isso é efetivamente o que o WaitForExit faz, mas também processa eventos de aplicativos, permitindo que a interface do usuário permaneça vagamente responsiva:

Propriedade Process. StandardError.
A documentação de referência da API. NET tem uma nova página. Visite o Navegador da API. NET em docs. microsoft para ver a nova experiência.
Obtém um fluxo usado para ler a saída de erro do aplicativo.
Assembly: System (no System. dll)
Valor da propriedade.
Um StreamReader que pode ser usado para ler o fluxo de erros padrão do aplicativo.
O fluxo StandardError foi aberto para operações de leitura assíncrona com BeginErrorReadLine.
Quando um processo grava texto em seu fluxo de erro padrão, esse texto é normalmente exibido no console. Ao redirecionar o fluxo StandardError, você pode manipular ou suprimir a saída de erro de um processo. Por exemplo, você pode filtrar o texto, formatá-lo de maneira diferente ou gravar a saída no console e em um arquivo de log designado.
Para usar o StandardError, você deve definir ProcessStartInfo. UseShellExecute como false e deve definir ProcessStartInfo. RedirectStandardError como true. Caso contrário, a leitura do fluxo StandardError gerará uma exceção.
O fluxo StandardError 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 de erro do processo. Essas operações de leitura síncrona não são concluídas até que o Processo associado grave em seu fluxo StandardError ou feche o fluxo.
Por outro lado, BeginErrorReadLine inicia operações de leitura assíncrona no fluxo StandardError. Esse método ativa um manipulador de eventos designado para a saída do fluxo e retorna imediatamente ao responsável pela chamada, 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 responsável pela chamada do fluxo StandardError e a gravação do processo filho nesse fluxo. Essas dependências podem resultar em condições de deadlock. Quando o chamador lê o fluxo redirecionado de um processo filho, ele depende do filho. O chamador aguarda na operação de leitura até que o filho grave no fluxo ou feche o fluxo. Quando o processo filho grava dados suficientes para preencher seu fluxo redirecionado, ele depende do pai. O processo filho aguarda na próxima operação de gravação até que o pai leia o fluxo completo ou feche o fluxo. A condição de deadlock resulta quando o chamador e o processo filho aguardam um ao outro para concluir uma operação e nenhum deles pode prosseguir. Você pode evitar deadlocks avaliando dependências entre o chamador e o processo filho.
O seguinte código C #, por exemplo, mostra como ler de um fluxo redirecionado e aguardar a saída do processo filho.
O exemplo de código evita uma condição de deadlock chamando p. StandardError. ReadToEnd antes de p. WaitForExit. Uma condição de deadlock pode resultar se o processo pai chama p. WaitForExit antes de p. StandardError. ReadToEnd e o processo filho grava texto suficiente para preencher o fluxo redirecionado. O processo pai aguardaria indefinidamente que o processo filho fosse encerrado. O processo filho esperaria indefinidamente que o pai lesse o fluxo completo do StandardError.
Há um problema semelhante quando você lê todo o texto da saída padrão e dos fluxos de erro padrão. O seguinte código C #, por exemplo, executa uma operação de leitura nos dois fluxos.
O exemplo de código evita a condição de deadlock executando operações de leitura assíncrona no fluxo StandardOutput. Uma condição de deadlock resulta se o processo pai chamar p. StandardOutput. ReadToEnd seguido por p. StandardError. ReadToEnd e o processo filho grava texto suficiente para preencher seu fluxo de erro. O processo pai esperaria indefinidamente que o processo filho fechasse seu fluxo StandardOutput. O processo filho esperaria indefinidamente que o pai lesse o fluxo completo do StandardError.
Você pode usar operações de leitura assíncronas para evitar essas dependências e seu potencial de deadlock. Como alternativa, você pode evitar a condição de deadlock criando dois threads e lendo a saída de cada fluxo em um thread separado.
Você não pode mesclar operações de leitura assíncrona e síncrona em um fluxo redirecionado. Depois que o fluxo redirecionado de um processo é aberto no 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 BeginErrorReadLine com uma chamada para ReadLine no fluxo StandardError 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.

c # como programaticamente executar exe e esperar até terminar a execução.
Então, no meu processo de desenvolvimento de um utilitário que utiliza um compressor javascript bem conhecido & # 8221; para compactar arquivos javascript. Eu me deparei com a necessidade de executar o Java. exe a partir do meu aplicativo c #.
Você deve estar ciente da classe Process no pacote System. Diagnostics.
Nós estaremos utilizando a classe Process para executar o java a partir da linha de comando e manter a janela oculta e também parar o fluxo do programa até que o executável do EXE termine a execução.
Se esta solução puder ser melhorada, por favor, deixe seus comentários, mas eu acho que é bastante padrão usando bibliotecas c #, então não pode dar errado com isso.