Waitforexit assíncrono

Waitforexit async
Obter através da App Store Leia esta publicação em nosso aplicativo!
process. WaitForExit (int32) de forma assíncrona.
Estou usando a solução fornecida em: stackoverflow / a / 19104345/2713516 para executar WaitForExit async, no entanto, eu quero usar a sobrecarga do parâmetro Int32 (msdn. microsoft/en-us/library/ty0d8k56(v=vs.110). aspx), como em processo. WaitForExit (10000).
Como altero este método de extensão para que ele funcione com o parâmetro de tempo limite?
Pergunta secundária: eu também vi alguém mencionado (stackoverflow / a / 32994778/2713516) que eu deveria descartar o cancelamento em algum momento, não deveria usar um dispositivo / usar dentro do método então? e como?
Você precisará alterar a assinatura do método e aplicar o resultado do próprio processo. Por exemplo, considere o seguinte:

Waitforexit async
Obter através da App Store Leia esta publicação em nosso aplicativo!
process. WaitForExit () de forma assíncrona.
Quero aguardar um processo para terminar, mas process. WaitForExit () trava minha GUI. Existe uma maneira baseada em eventos, ou eu preciso gerar um segmento para bloquear até sair, depois delegar o evento eu mesmo?
A partir de 4.0 / C # 5, é melhor representar isso usando o padrão assíncrono.
Se você escolher a resposta do MgSam, esteja ciente, se você passar por WaitForExitAsync algum CancelamentoToken, que será automaticamente cancelado após o atraso especificado, você pode obter uma InvalidOperationException. Para corrigir isso, você precisa mudar.
P. S .: não esqueça de dispor o seu CancelamentoTokenSource no tempo.
De acordo com este link, o método WaitForExit () é usado para fazer o thread atual aguardar até o processo associado terminar. No entanto, o processo possui um evento Exitado ao qual você pode se conectar.

Waitforexit async
Pareceu-me que este sistema de assincronia era uma solução gloriosa para um problema que eu tenho tido onde preciso iniciar um processo externo e depois aguardo a conclusão. Atualmente, eu tenho o seguinte código no subtítulo UI:
Processo process = new Process ();
O processo geralmente leva vários segundos, mas resisti com o uso de um trabalhador em segundo plano ou similar porque simplesmente não acontece com freqüência suficiente para valer a pena o esforço e codificação de código.
Eu vi menção de métodos de extensão no whitepaper, mas parece não haver nenhum método de extensão para process. RunAsync () ou algo similar, deixando "aguardar TaskEx. Run (() = & gt; process. WaitForExit ()); & quot; como a única solução que parece que vai funcionar. Girar um fio extra apenas para chamar WaitForExit parece bastante estúpido.
Eu também não encontrei nenhum método estático que parecia promissor em qualquer AsyncCtpExtensions, AsyncCtpThreadingExtensions, TaskEx ou TaskExtensions.
Existe uma (planejada) melhor maneira de aguardar a conclusão do processo externo?
A desvantagem de usar o pool dessa maneira é que você estará bloqueando um segmento durante a duração do processo. Se você não está girando muitos processos, isso pode não ser um grande problema, mas ainda não há necessidade real de fazê-lo. Em vez disso, você pode usar uma tarefa que não está vinculada a um tópico, p.
public static Task ExitedAsync (este Processo p)
var tcs = new TaskCompletionSource & lt; object & gt; ();
p. Exited & # 43; = (s, e) = & gt; tcs. TrySetResult (null);
se (p. HasExited) tcs. TrySetResult (null);
Com isso, você pode escrever:
e você não estará bloqueando nenhum segmento enquanto espera assíncronamente o processo sair.
Proposta como resposta por Stephen Toub - empregado da Microsoft MSFT, moderador sexta-feira, 29 de outubro de 2010 9:29 PM Marcado como resposta por Lucian Wischik, empregado da Microsoft MSFT, proprietário sábado, 30 de outubro de 2010 22:13.
Todas as respostas.
& quot; Girar um fio extra apenas para chamar WaitForExit parece bastante estúpido. & Quot;
Se você usar a funcionalidade TPL padrão, por padrão, ele usará um thread ThreadPool. Realmente não deve haver muito tempo de espera para "girar" e " o segmento. Uma vez que isso é algo que & quot; não acontece com bastante frequência para valer a pena o esforço e codificação de código ", eu simplesmente usaria:
Se uma postagem responder sua pergunta, clique em & quot; Marcar como resposta & quot; naquela postagem e & quot; Marque como Útil ".
A desvantagem de usar o pool dessa maneira é que você estará bloqueando um segmento durante a duração do processo. Se você não está girando muitos processos, isso pode não ser um grande problema, mas ainda não há necessidade real de fazê-lo. Em vez disso, você pode usar uma tarefa que não está vinculada a um tópico, p.
public static Task ExitedAsync (este Processo p)
var tcs = new TaskCompletionSource & lt; object & gt; ();
p. Exited & # 43; = (s, e) = & gt; tcs. TrySetResult (null);
se (p. HasExited) tcs. TrySetResult (null);
Com isso, você pode escrever:
e você não estará bloqueando nenhum segmento enquanto espera assíncronamente o processo sair.
Proposta como resposta por Stephen Toub - empregado da Microsoft MSFT, moderador sexta-feira, 29 de outubro de 2010 9:29 PM Marcado como resposta por Lucian Wischik, empregado da Microsoft MSFT, proprietário sábado, 30 de outubro de 2010 22:13.
Muito verdadeiro. Eu esqueci que o Processo efetivamente implementa o padrão EAP dessa maneira. Esta é uma opção muito melhor para minha sugestão.
Se uma postagem responder sua pergunta, clique em & quot; Marque como resposta & quot; naquela postagem e & quot; Marque como Útil ".
A Microsoft está conduzindo uma pesquisa on-line para entender sua opinião sobre o site da Msdn. Se você optar por participar, a pesquisa on-line será apresentada quando você sair do site do Msdn.

Aguarde Extensões. Aguarde Sair Assíncrono (Processo, CancelamentoToken) Aguarde Extensões. Aguarde o método Sair Assínc. (Processo, CancelamentoToken).
Definição.
Neste artigo.
Retorna uma tarefa que conclui quando o processo sai e fornece o código de saída desse processo.
O processo para aguardar a saída.
Um token cujo cancelamento fará com que a Tarefa retornada seja concluída antes que o processo seja encerrado em um estado falhado com uma OperaçãoExcluída. Este token não tem efeito sobre o próprio processo.
Uma tarefa cujo resultado é o ExitCode do processo.

Processo . Método WaitForExit ()
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.
Instrui o componente Processo a esperar indefinidamente para que o processo associado saia.
Assembly: System (no System. dll)
A configuração de espera não pôde ser acessada.
Nenhum Id do processo foi configurado e um identificador do qual a propriedade Id pode ser determinada não existe.
Não existe nenhum processo associado a este objeto Processo.
Você está tentando chamar WaitForExit () para um processo que está sendo executado 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. Ele deve ser chamado após todos os outros métodos serem 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. Isso pode fazer com que um aplicativo pare de responder. Por exemplo, se você chamar CloseMainWindow para um processo que tenha uma interface de usuário, a solicitação ao sistema operacional para encerrar o processo associado pode não ser tratada se o processo for gravado para nunca entrar no loop de mensagem.
No Quadro 3.5 e versões anteriores, a sobrecarga WaitForExit () esperava milissegundos MaxValue (aproximadamente 24 dias), não indefinidamente. Além disso, as versões anteriores não esperaram que os manipuladores de eventos saíssem se o tempo MaxValue completo fosse atingido.
Esta sobrecarga garante que todo o processamento foi 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 WaitForExit (Int32) quando a saída padrão foi redirecionada para manipuladores de eventos assíncronos.
Quando um processo associado sai (ou seja, quando é encerrado pelo sistema de operação através de um término normal 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, que inclui o ExitTime, usando o Handle para o processo encerrado.
Como o processo associado saiu, a propriedade Handle do componente já não 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 manipulações para processos que não foram lançados pelos componentes do Processo, portanto, mantém as informações ExitTime e Handle na memória até que o componente Processo liberte especificamente os recursos. Por esse motivo, sempre que você ligar para uma instância do Start for Process, chame Close quando o processo associado for encerrado e você não precisa mais de informações administrativas sobre isso. Close libera a memória alocada para o processo finalizado.
Consulte a seção Comentários da página de referência da propriedade StandardError.
para confiança total para o chamador imediato. Este membro não pode ser usado por código parcialmente confiável.

Propriedade Process. StandardError.
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 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íncronas 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 StandardError, você deve definir ProcessStartInfo. UseShellExecute como falso e você deve definir ProcessStartInfo. RedirectStandardError como verdadeiro. 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 escreva em seu fluxo StandardError ou encerre o fluxo.
Em contraste, BeginErrorReadLine inicia operações de leitura assíncronas no fluxo StandardError. 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 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 impasse. 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 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 dependências entre o chamador e o 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. StandardError. ReadToEnd antes de p. WaitForExit. Uma condição de impasse 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 esperaria indefinidamente para que o processo filho saísse. O processo filho esperaria indefinidamente para o pai ler do fluxo completo do StandardError.
Há um problema semelhante ao ler 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 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 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.
O exemplo a seguir usa o comando net use junto com um argumento fornecido pelo usuário para mapear um recurso de rede. Em seguida, ele lê o fluxo de erro padrão do comando net e o grava no console.
para confiança total para o chamador imediato. Este membro não pode ser usado por código parcialmente confiável.