Vb net waitforexit timeout

Vb net waitforexit timeout
Obter através da App Store Leia esta publicação em nosso aplicativo!
Como usar Process. WaitForExit.
Estou chamando um aplicativo da 3ª parte que "às vezes" funciona no VB (é um WCF autônomo). Mas às vezes o aplicativo de terceiros pendura para sempre, então adicionei um temporizador de 90 segundos. O problema é, como eu sei se o tempo expirou?
O código parece assim:
O que eu gostaria de fazer é algo assim.
Verifique o valor de retorno do método - msdn. microsoft/en-us/library/ty0d8k56.aspx - se a chamada expirar, ele retornará False.
Houve problemas conhecidos no passado em que os aplicativos congelariam ao usar WaitForExit.

George Birbilis @zoomicon.
Engenheiro de informática, Microsoft MVP J # & # 8211; R & amp; D 2004-2018, Borland Spirit of Delphi 2001.
Gotchas at Wait para um aplicativo descascado terminar (com / sem tempo limite) com.
Encontrei um exemplo útil do suporte da Microsoft chamado "Como aguardar a conclusão de um aplicativo descascado usando Visual Basic 2005 ou Visual Basic" em support. microsoft/kb/305368.
No entanto, note que existem várias gotchas com o código fornecido lá (apenas informou a Microsoft sobre isso, espero que eles tomem nota). Também o artigo aponta para as versões C # e C ++ da amostra que, obviamente, precisam das mesmas correções.
1) existe um problema tanto na primeira amostra (espere indefinidamente) como no segundo (espera com tempo limite)
& # 8216; Aguarde a janela de processo para concluir o carregamento.
& # 8216; Aguarde até que o processo saia.
Por que esperar pela entrada ocioso em primeiro lugar? O processo pode nunca entrar no estado ocioso e sair antes disso. De acordo com msdn. microsoft/en-us/library/8d7363e2(v=VS.90).aspx, você pode obter exceção de WaitForInputIdle:
Ocorreu um erro desconhecido. O processo não conseguiu entrar no estado ocioso.
O processo já foi encerrado.
Nenhum processo está associado a este objeto Processo.
Suponho que seja melhor evitar chamar WaitForInputIdle, pois você apenas se importa com WaitForExit lá.
2) Mesmo WaitForExit pode lançar exceções que o código deve verificar de acordo com msdn. microsoft/en-us/library/fb4aw7b8.aspx.
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.
3) O artigo de suporte não menciona o documento WaitForExit (timeout) (msdn. microsoft/en-us/library/fb4aw7b8.aspx) sobre o tempo limite "infinito":
No Framework versão 3.5 e versões anteriores, a sobrecarga WaitForExit aguardava 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.
Além disso, parece que a documentação para "WaitForExit (timeout)" não menciona que existe uma constante Timeout. Infinite que tem o valor -1 a usar para tais tempos limite infinitos (encontrado a partir do documento de Thread. Join): msdn. microsoft/ en-us / library / system. threading. timeout. infinite (v = VS.90).aspx.
4) A amostra não consegue chamar Close e, portanto, continua a gastar recursos para controlar o rastreamento (e "bloquear" aqueles identificadores de identificadores, obviamente, embora não seja tão fácil quanto em CPUs antigas e versões do sistema operacional ficar sem alças, espero).
Quando um processo associado sai (ou seja, quando é desligado 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 a informação do sistema operacional n. ° 8217 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. Fechar libera a memória alocada para o processo encerrado.
Observe também que poderia ter uma cláusula "Usando" ao definir o novo objeto de processo (em vez de Dim) em vez de obrigar explicitamente a "Processar fechar" no final para liberar recursos, conforme observado em msdn. microsoft/en - us / library / system. diagnostics. process. close (v = VS.90).aspx.
O método Fechar faz com que o processo pare de aguardar a saída se ele estivesse esperando, fecha o identificador do processo e limpa as propriedades específicas do processo. Fechar não fecha os leitores e escritores padrão de saída, entrada e erro caso estejam sendo referenciados externamente.
O método Dispose (Boolean) chama Close. Colocar o objeto Processo em um bloco de uso dispõe de recursos sem a necessidade de chamar Close.
5) Outro problema está na 2ª amostra (aguarde com tempo limite). Não menciona ter que chamar WaitForExit () novamente sem params após o WaitForExit (timeout) no caso em que a saída padrão foi redirecionada para manipuladores de eventos assíncronos (deve mencionar este caso para completude)
Quando a saída padrão foi redirecionada para manipuladores de eventos assíncronos, é possível que o processamento de saída não seja concluído quando esse método retornar. Para garantir que o tratamento de eventos assíncrono tenha sido concluído, chame a sobrecarga WaitForExit que não leva nenhum parâmetro depois de receber uma verdade dessa sobrecarga. Para ajudar a garantir que o evento Exited seja tratado corretamente nas aplicações Windows Forms, defina a propriedade SynchronizingObject.

Processo . Método WaitForExit (Int32)
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 aguardar o número especificado de milissegundos para que o processo associado saia.
Assembly: System (no System. dll)
Parâmetros.
A quantidade de tempo, em milissegundos, para aguardar o encerramento do processo associado. O máximo é o maior valor possível de um inteiro de 32 bits, que representa infinito para o sistema operacional.
Valor de retorno.
é verdade se o processo associado tenha saído; caso contrário, falso.
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 (Int32) 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 (Int32) 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 um período finito de tempo para o processo sair. Se o processo associado não sair pelo final do intervalo porque a solicitação de término é negada, o falso é retornado ao procedimento de chamada. Você pode especificar um número negativo (Infinito) por milissegundos e Processar. WaitForExit (Int32) irá comportar-se da mesma forma que a sobrecarga WaitForExit (). Se você passar 0 (zero) para o método, ele retorna verdadeiro somente se o processo já foi encerrado; Caso contrário, ele retorna imediatamente falso.
No Quadro 3.5 e versões anteriores, se o milissegundo fosse -1, a sobrecarga WaitForExit (Int32) esperava milissegundos MaxValue (aproximadamente 24 dias), não indefinidamente.
Quando a saída padrão foi redirecionada para manipuladores de eventos assíncronos, é possível que o processamento de saída não seja concluído quando esse método retornar. Para garantir que o tratamento de eventos assíncrono tenha sido concluído, chame a sobrecarga WaitForExit () que não leva nenhum parâmetro depois de receber uma verdade dessa sobrecarga. Para ajudar a garantir que o evento Exited seja tratado corretamente nas aplicações Windows Forms, defina a propriedade SynchronizingObject.
Quando um processo associado é encerrado (é encerrado pelo sistema operacional através de uma terminação normal ou anormal), o sistema armazena informações administrativas sobre o processo e retorna ao componente que chamou WaitForExit (Int32). 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. Fechar libera a memória alocada para o processo encerrado.
Consulte o exemplo de código para a propriedade ExitCode.
para uma confiança total para o chamador imediato. Este membro não pode ser usado por código parcialmente confiável.

Pare até terminar o processo.
Estou escrevendo um pequeno aplicativo para colecionar o comando de comando do IE. O problema é que não está aguardando até o processo terminar e erros na próxima linha. Meu objetivo é copiar o log e colá-lo em uma pasta na área de trabalho.
O que estou fazendo de errado. E por favor, tenha em mente que eu sou um recruta no VB.
Existem duas maneiras de fazê-lo. Primeiro é esperar.
para que o processo saia.
Segundo é aguardar o evento que um processo aumenta quando terminar:
Estou tentando o primeiro método. Mas recebo um erro "A referência a um membro não compartilhado requer uma referência de objeto.
aqui está o código:
Desculpe, trabalhei.
Declarou-o primeiro.
Dim myProcess As Process = System. Diagnostics. Process. Start ("C: \ Arquivos de Programas \ Internet Explorer \ iediagcmd. exe")
Então, use myProcess. WaitForExit () agora funciona.
Obrigado pelo ajudante.
Como limpar o formulário após o sucesso enviar usando a resposta php-1 SincronizadoMap ConcorrenteModificaçãoExcepção - 1 resposta proteger a senha - 1 resposta Lendo um arquivo. raw e exibir como hexágono - 8 respostas Bloco sincronizado no método principal - 3 respostas Finalmente não executado após tentar bloquear - 3 responde como ligar o botão de exclusão da base de dados ao botão de exclusão do site - 1 resposta login Erro MySQL quando o programa é executado - 4 respostas C # windows forma TCP thread cross thread operação não válido erro? - 1 resposta Colisão lateral do círculo retângulo. - 39 respostas GUI Layout Manager - 4 respostas Python: Compare dois arquivos CSV - Diferenças / adições de saída - 7 respostas Problema atualizando após adicionar dados - 5 respostas Problema de colisão de círculo / bola. - 14 respostas Movendo automaticamente um Bot através de um labirinto usando a regra da mão direita - 2 respostas Fazendo login e senha logon e registrando-se para um jogo - 2 respostas Detectar Dispositivos Android próximos - 9 respostas Scanner de código de barras Android - 4 respostas Procurar e excluir dados em DatagridView - 1 resposta Renderer Não atualizando - 5 respostas.
Estou tentando entender o SynchronizedMap e corri o código abaixo. Recebo a saída abaixo com uma exceção. Segundo meu entendimento, a exceção é causada quando.
Estou tentando fazer esse formulário para limpar depois de ser enviado. Como é agora, o formulário é enviado, no entanto, os campos de entrada não são limpos e quando.
Então, o título pode parecer confuso, então espero que eu possa me explicar melhor através do corpo do fio. Estou desenvolvendo um aplicativo para um amigo que deseja.

Gerenciando Processos em.
Por Leonardo Esposito.
Leonardo Esposito.
Dino Esposito é o autor de "Programação ASP MVC" para a Microsoft Press, bem como "Programação ASP 4" e outros livros mais vendidos, como "Microsoft ®: Arquitetura de Aplicações para a Empresa". Contribuinte regular para o MSDN Magazine e DevProConnections Magazine, a Dino é um orador freqüente em eventos da indústria em todo o mundo, incluindo Microsoft TechED e DevConnections. Após uma década de desenvolvimento na Web, Dino saltou no movimento móvel e está se desenvolvendo ativamente para iOs, Android e WP7.
Este artigo foi publicado em:
Este artigo foi arquivado em:
A classe Process permite que você obtenha controle total sobre os processos do sistema.
Você pode iniciar e interromper processos e recuperar informações sobre a execução de processos, como a lista de módulos carregados e as características da memória ocupada. A classe também possui métodos úteis para saber se um processo está respondendo ou acabou de sair e com qual código de retorno. Os programadores também têm controle total sobre o estilo da janela em que o processo é executado. Após uma visão geral dos recursos da classe Process, este artigo demonstra como ocultar a execução de processos do console, monitorar sua execução e capturar qualquer saída. Eu usarei essa estratégia para criar uma amostra da classe de Compressão a ser usada com WinZip e gzip (ferramentas populares para comprimir dados).
Você já quis gerenciar processos no código Win32? Quando se trata disso, há boas e más notícias. No lado das boas notícias, você pode fazer praticamente tudo o que desejar, incluindo bloquear seu processo atual aguardando a conclusão de outro processo. Sobre o lado das más notícias, você deve trabalhar com uma API que não é uma para os fracos. CreateProcess é a função one-size-fits-all que cria um novo processo do Win32 e gerencia as configurações de personificação e segurança. Esta função tem uma sintaxe bastante peculiar. O Win32 SDK fornece várias funções, incluindo CreateProcess e OpenProcess, que fornecem as principais funcionalidades. O Win32 SDK fornece ToolHelp API, um SDK secundário, mas não está disponível em todas as combinações possíveis de sistemas operacionais Win32. A API ToolHelp oferece funções mais avançadas, incluindo a capacidade de listar módulos e dependências, capturar a pegada de memória e o processo de ping.
A classe Process fornece acesso a processos locais e remotos e permite que você comece e pare processos na máquina local. A classe representa um superconjunto dos recursos da API CreateProcess Win32.
Muito bem, agrupa todos esses serviços de plataforma em uma única classe - a classe Process. Tudo o que você precisa fazer, envolve a criação de um novo processo ou o controle de uma execução, você pode fazer a partir deste ponto de entrada único (e bastante poderoso).
A Classe Processo.
A classe Process fornece acesso a processos locais e remotos e permite que você comece e pare processos na máquina local. A classe representa um superconjunto dos recursos da API CreateProcess Win32. Além disso, a classe Process faz com que o trabalho com a execução de instâncias de aplicativos seja particularmente fácil. Por exemplo, você só precisa de uma única linha de código para iniciar um novo processo dentro de um aplicativo:
Se você precisa abrir um documento específico, digamos, um documento do Word, é ainda mais fácil.
Nesse caso, a classe Process é inteligente o suficiente para descobrir que o argumento não é um executável. Ele procura o registro do sistema para uma correspondência na extensão (.doc neste caso), obtém o executável associado a esse tipo de arquivo e o inicia. Esse comportamento revela outra poderosa função da API Win32 trabalhando sob o capô? ShellExecuteEx, que é projetado para abrir um documento - seja um executável (ou seja, um arquivo. exe ou. bat) ou um arquivo de documento associado a um programa (como um arquivo. txt ou um arquivo. doc).
A classe Process tem métodos de instância e compartilhado (estático, se você fala C #). A Tabela 1 lista todos os métodos expostos pela classe. Olhar para a mesa dará uma idéia clara das capacidades da classe.
Você tem duas maneiras de encerrar um processo? Kill e CloseMainWindow. O primeiro interrompe a execução imediatamente, enquanto que o último simplesmente coloca uma mensagem de término na fila de mensagens. O método Kill pode causar perda de dados se atingir o processo em um estágio crítico. Você deve usar o método Kill se você tiver que encerrar programaticamente um programa que não possui uma interface gráfica do usuário (como um programa de console ou um serviço de sistema). Você sempre deve usar o CloseMainWindow para parar os programas GUI.
Você pode ter uma situação de programação na qual você precisa gerar um programa externo e aguardar a conclusão. Por padrão, um processo gerado é executado independentemente do pai. Para sincronizar os dois para que o pai retome quando a criança foi concluída, você usa o método WaitForExit. WaitForExit é um método baseado em instância que requer uma nova instância da classe Process para funcionar.
O método Start possui várias sobrecargas; alguns compartilhados e baseados em instâncias. A sobrecarga baseada em instância não aceita parâmetros. Para especificar o nome do executável a ser executado, você precisa instanciar e preencher uma classe chamada ProcessStartInfo. Vamos descobrir mais sobre esta classe e processar informações em geral.
Descubra as informações do processo.
Um processo em execução tem muita informação para mostrar. Em primeiro lugar, um processo em execução possui uma identificação única que o identifica ao longo de toda a vida. Se o processo for um programa GUI, ele também possui um identificador de janela e uma string de título. De um lado mais técnico, a classe Process mantém informações sobre os segmentos gerenciados pelo processo e os módulos (ou seja, montagens e DLLs) carregados. A classe de processo rastreia a pegada da memória e retorna informações detalhadas através de uma variedade de propriedades. A Tabela 2 lista todas as propriedades disponíveis na classe Processo.
Uma vez que os aplicativos do Windows Forms suportam apenas o modelo de apartamento single-thread (STA), você deve garantir que o segmento que manipula o evento Exited e o segmento que criou o controle Windows Forms que deseja atualizar coincidem.
A propriedade Responding retorna um valor booleano que indica se o processo está ativo e funcionando. O valor resulta de um ping operado na janela principal do processo. Basicamente, quando você tenta ler o valor da propriedade, o acessador de acesso da propriedade envia uma mensagem do Windows para a janela com um tempo limite de cinco segundos. Ele utiliza a API SendMessageTimeout Win32. Se a função expirar, então o processo é considerado não respondendo.
A classe Process também dispara um evento, Exited, quando o processo associado termina. Este evento não dispara automaticamente todas as vezes que um processo termina. Se você quiser disparar esse evento, ative a propriedade Boleiro EnableRaisingEvents. Essa propriedade está definida como Falso por padrão.
Se você decidir lidar com o evento Exitado, provavelmente você precisará acessar um controle do Windows Forms dentro do manipulador de eventos para atualizar a interface do usuário. Uma vez que os aplicativos do Windows Forms suportam apenas o modelo de apartamento single-thread (STA), você deve garantir que o segmento que manipula o evento Exited e o segmento que criou o controle Windows Forms que deseja atualizar coincidem. Isso não é necessariamente verdadeiro por padrão e pode levar a anomalias ou mesmo exceções. Para contornar esse problema, você pode definir a propriedade SincronizandoObjeto da classe Processo no controle do Windows Forms que você está interessado principalmente (ou qualquer controle no mesmo formulário UI). Isso garante que o aplicativo executa o manipulador de eventos Exitado no mesmo tópico que gerencia o formulário.
Para dar sentido aos métodos e propriedades na Tabela 1 e na Tabela 2, vamos construir um applet de amostra que exiba algumas das informações que você normalmente obtém através do Gerenciador de Tarefas do Windows. A Listagem 1 mostra o código que captura algumas informações sobre todos os processos atualmente ativos e preenche um controle ListView com nomes, conjunto de trabalho e hora de início.
O método compartilhado GetProcesses retorna uma matriz de objetos do Processo, um por cada processo ativo. O código na listagem 1 abrange o array e adiciona um item a um controle ListView com os valores das propriedades ProcessName, WorkingSet e StartTime. Esta informação e, em particular, o conjunto de trabalho, corresponde ao exibido pelo Gerenciador de Tarefas do Windows (Figura 1).
Figura 1: um aplicativo de exemplo baseado na API de processo que imita o Gerenciador de Tarefas do Windows.
Na Figura 1, você também vê um segundo controle ListView preenchido com informações de módulos. Um processo ativo consiste em vários módulos, isto é, bibliotecas de carga dinâmicas de que depende alguma funcionalidade. A propriedade Módulos retorna uma coleção de objetos ProcessModule, cada um aponta para uma biblioteca ou conjunto diferente. A Listagem 2 mostra o código-fonte que preenche o segundo controle ListView quando um processo é selecionado.
Especifique informações de inicialização.
Quando você inicia um novo processo, especialmente se o programa é um programa de console, você precisa passar alguns argumentos de linha de comando. Como você faz isso? O método Compartilhamento iniciado possui uma sobrecarga que permite que você passe uma linha de comando como uma seqüência de caracteres.
Quando seu aplicativo usa uma sobrecarga compartilhada do método Start, ele sempre cria um novo objeto Processo. Se você quiser iniciar um novo processo com base em uma instância existente da classe Process, use a versão baseada em instância do método Start. No entanto, neste caso, você não pode especificar nenhum parâmetro porque a assinatura do método não o permite. Qualquer informação de inicialização deve ser especificada através da classe ProcessStartInfo.
A propriedade FileName permite que você indique o nome do executável para gerar. A propriedade Arguments permite que você defina a seqüência de linha de comando. No entanto, usar a classe ProcessStartInfo é um pouco demais se você precisa apenas especificar o executável e uma linha de comando. Existem outros motivos para usar informações de inicialização. A Tabela 3 lista as propriedades da classe ProcessStartInfo.
No caso de saída redirecionada, a classe Process acumula a saída em um fluxo de memória em vez de apenas enviá-lo para a saída do console. Você pode então acessar qualquer saída de bytes através da propriedade StandardOutput da classe Processo.
A classe ProcessStartInfo possui muitas propriedades interessantes. Eu me concentro em alguns deles: CreateNoWindow, Verb e as três propriedades de redirecionamento (RedirectStandardError, RedirectStandardInput e RedirectStandardOutput). A propriedade Boolean CreateNoWindow instrui a classe Process para não exibir uma janela ao executar o programa. Isso é bom quando você precisa executar um processo de console em segundo plano e você não quer que a tela preta feia do console do MS-DOS apareça. Para garantir que a janela do console não apareça, você deve ter a API CreateProcess iniciando o processo definindo a propriedade UseShellExecute como falsa.
Cada arquivo no Windows tem um menu de contexto e cada menu de contexto possui um conjunto de verbos predefinidos, como Abrir e Imprimir. O Windows define os verbos com base no tipo do arquivo (ou seja, a extensão) no registro do sistema. No final, um verbo é uma string; a propriedade Verbos retorna uma matriz de strings preenchida com os verbos encontrados para o tipo de arquivo definido na propriedade FileName. Cada tipo de arquivo tem um verbo padrão, normalmente aberto. Quando você inicia um processo através do shell (veja UseShellExecute), o Windows executa seu verbo padrão. Como mencionei, na maioria dos casos, esse verbo é aberto e o programa é executado ou o documento é aberto. No entanto, esteja ciente de que este é um parâmetro configurável.
Impressão a partir do Shell.
Você pode explorar o suporte incorporado para verbos de shell para enriquecer seus aplicativos com funções expostas por outros programas. Por exemplo, suponha que você precise imprimir um arquivo de texto. simplificou quase todas as operações em comparação com a plataforma Win32. A impressão é, talvez, uma das poucas exceções. Mesmo dentro, escrever o código que imprime um documento é uma tarefa chata. Se você não é muito pretensioso, você pode se contentar com o mecanismo de impressão no Bloco de Notas. O executável Notepad aceita a opção / p na linha de comando e imprime o documento especificado.
A API shell fornece um atalho interessante para imprimir documentos de texto. A API de processo suporta totalmente esse atalho através da propriedade Verbo. O snippet de código abaixo demonstra como imprimir um arquivo de texto usando o verbo de impressão do programa registrado para lidar com arquivos. txt. Por padrão, este programa é notepad. exe.
Este fragmento funciona independentemente do programa que você registrou no seu computador para lidar com arquivos de texto. De modo algum é dependente do notepad. exe. Ele falha apenas se, por algum motivo, você não possui um programa associado a arquivos de texto. A coleção Verbos retorna a lista de todos os verbos personalizados definidos no arquivo especificado. Um valor viável para a propriedade Verbo é qualquer string contida na coleção Verbs.
Observe que quando você invoca um verbo, o Windows lança o programa associado e ele faz algum trabalho no arquivo especificado. Isso significa que o arquivo de texto será aberto primeiro em notepad. exe (ou qualquer programa associado a arquivos. txt) e, em seguida, impresso automaticamente usando a interface do usuário do programa. Se você usar verbos, você deve garantir que você configure UseShellExecute como Verdadeiro.
Capturar a saída do processo.
Um programa de console recebe sua entrada a partir da linha de comando ou a entrada padrão do console, e envia sua saída para a saída padrão da consola. Além disso, envia automaticamente mensagens de erro para um fluxo de saída separado.
Com base nos recursos da API Win32, você pode substituir os fluxos de entrada, saída e erro com fluxos personalizados. Por exemplo, suponha que você use a seguinte sintaxe do prompt do console:
Qualquer saída que o executável gerará é redirecionada automaticamente para o arquivo de texto especificado. A API do processo fornece a mesma funcionalidade através de um conjunto de propriedades orientadas a objetos e fáceis de usar. Vamos ver como capturar a saída de um processo para uma string.
Para começar, você deve garantir que você definiu a propriedade RedirectStandardOutput como True. O valor padrão é falso. No caso de saída redirecionada, a classe Process acumula a saída em um fluxo de memória em vez de apenas enviá-lo para a saída do console. Você pode então acessar qualquer saída de bytes através da propriedade StandardOutput da classe Processo. O snippet de código a seguir abre a caixa de console, executa uma declaração dir e captura a saída. A Figura 2 mostra o resultado.
Figura 2: A saída de uma instrução de log MS-DOS capturada para uma string e exibida através de uma chamada MsgBox.
O nome do arquivo é cmd. exe, que é o executável do sistema para a caixa de console. Observe que o nome do arquivo e os argumentos são entidades separadas para a classe Process. Qualquer coisa atribuída à propriedade FileName é considerada como o nome do arquivo, incluindo switches e parâmetros. A opção / c no argumento acima indica que a janela de comando deve ser fechada imediatamente após o término do comando. Usar as configurações para UseShellExecute e CreateNoWindow garante que nenhuma janela preta será exibida, nem mesmo por um momento.
Quando o comando foi concluído, o fluxo de saída, um objeto de fluxo de memória, contém todos os bytes emitidos pelo programa. Você pode ler este fluxo usando a API clássica de um objeto Stream. Por exemplo, o método ReadToEnd lê todo o conteúdo do fluxo para uma string.
Existe alguma vantagem concreta na execução de aplicativos de console em uma janela oculta? Bem, isso depende do que o seu programa de console faz. Se o seu programa de console fornecer um recurso essencial que não seja de outro modo, esse truque estabelece um marco importante na incorporação dessa funcionalidade em seus aplicativos. Você sabe como executar esse programa em uma janela invisível; Você sabe como configurá-lo através de sua linha de comando; Você sabe como capturar sua saída. Ao adicionar um pouco de análise na saída gerada, você pode facilmente descobrir o que o programa fez, seus resultados e código de retorno. Para demonstrar essa possibilidade, vou criar uma pequena classe para limpar arquivos.
Funções do Zip Wrapping.
O Framework não inclui nenhuma classe para compactar arquivos. Muitos vendedores de terceiros vendem classes bem desenhadas que se conectam ao Framework e estendem-no com vários sabores da funcionalidade de compactação de arquivos. Alguns programas estão disponíveis em vários contratos de licença para zip e descompactar arquivos e pastas. Um deles é gzip (veja gzip), uma ferramenta de linha de comando. Outro é WinZip (veja winzip). Ao contrário do gzip, o WinZip é um programa GUI e não se presta muito bem para ser usado como uma ferramenta de fundo. No site WinZip, no entanto, você pode baixar alguns utilitários de linha de comando? wzzip e wzunzip. O snippet de código abaixo ilustra brevemente como usar essas ferramentas. (Para mais informações, consulte a documentação respectiva de cada ferramenta.)
O utilitário gzip cria um arquivo com o mesmo nome que o arquivo fonte mais uma extensão. gz. Por exemplo, se você tentar zip sample. doc, a ferramenta cria um arquivo chamado sample. doc. gz. O utilitário wzzip comprime o arquivo de origem e cria um novo arquivo com o nome especificado. Finalmente, a terceira linha de comando lista os arquivos contidos no arquivo ZIP especificado. Vamos combinar essas linhas de comando com a API do processo para criar uma nova classe para limpar arquivos.
O Listado 3 mostra o código-fonte do método Gzip na classe Compressor. É preciso duas strings? Fonte e destino? E cria um novo arquivo, cortando a fonte usando o utilitário gzip. Para que o código funcione, o utilitário gzip deve estar disponível em um diretório acessível ao público. (Por exemplo, você pode colocar o gzip no mesmo diretório que o programa de exemplo ou o diretório do Windows.)
Todas as instâncias da classe Compressor compartilham o método Gzip. Chamar a classe Compressor para zip um arquivo é fácil:
O utilitário gzip não produz qualquer saída significativa para a captura. Como o utilitário sempre adiciona uma extensão. gz ao arquivo de origem, adicionei algum código extra para renomear o arquivo compactado para o nome especificado. O método Run encapsula a lógica necessária para configurar e invocar a classe Process.
A Listagem 4 mostra o código-fonte do método Zip. Ele usa o utilitário wzzip para criar um arquivo. zip familiar. Observe que um arquivo. gz é reconhecido e tratado com êxito pelo WinZip, mas não pela extensão padrão do Windows XP para arquivos ZIP. O método Zip é simplesmente um invólucro em torno do método Run (Lista 3).
O método Zip comprime o arquivo de origem usando o algoritmo ZIP e cria um novo arquivo (o destino). Se o parâmetro de origem fizer referência a uma pasta, o Compressor irá compactar todos os conteúdos (arquivos e subpastas).
O método ReadZip demonstra como a saída de captura útil pode ser. O método ReadZip invoca o utilitário wzunzip com a opção? Vb e lista todos os arquivos contidos no arquivo ZIP especificado. O método primeiro captura a saída (Figura 3) e, em seguida, analisa-a para construir um objeto DataTable. A Figura 3 mostra a saída original do utilitário wzunzip.
Figura 3: A saída original do utilitário wzunzip.
O código de análise depende da versão do utilitário que você usa e pode quebrar se você usar uma nova versão do WinZip com um esquema de saída diferente. Este diagrama de exemplo ignora o cabeçalho e as linhas de fuga e quebra cada linha na listagem em pedaços usando uma expressão regular para detectar cadeias em branco. Note que extrair o nome do arquivo é um pouco complicado porque um nome de arquivo pode conter espaços em branco. Por esse motivo, meu utilitário recupera o nome do arquivo por posição. A Figura 4 mostra a mesma saída pós-processada para um DataTable e vinculada a um DataGrid.
Figura 4: A saída do utilitário wzunzip foi analisada e transformada em um DataTable.
Conclusão.
A Microsoft criou o processo API no Framework para facilitar a programação. Para muitas tarefas de nível de sistema, o Framework ainda depende fortemente dos recursos e das funções do sistema operacional e da API Win32. A API do processo não é uma exceção. No entanto, a camada de abstração que o Framework constrói unifica todas as várias funções da API Win32 (CreateProcess, ToolHelp, shell) em uma única API orientada a objetos. Eu acho que os objetos de programação com a classe Process são muito mais fáceis do que programar funções peculiares com muitos ponteiros e parâmetros. Você não concorda?
Modo de depuração e Privilégio de depuração.
Observe que o método EnterDebugMode não coloca o processo atual no modo de depuração? Bastante ao contrário. EnterDebugMode permite que o processo atual atue como um depurador. O método atribui um privilégio especial ao segmento atual? SeDebugPrivilege. Esse privilégio habilita o processo atual a depurar qualquer outro processo, desde que conheça o ID do processo. O método LeaveDebugMode revoga o privilégio para o processo atual. Somente quando concedido o privilégio de depuração, um processo pode ser anexado a outros processos que são executados no modo de depuração.
Desativando a Pasta Comprimida Padrão no Windows XP e no Windows Server 2003.
Windows XP e Windows Server 2003 vêm com um zíper incorporado que torna o WinZip aparentemente desnecessário. O recurso de pasta compactada é uma extensão de espaço para nome que fecha e descompacta arquivos e pastas de forma bastante natural. No entanto, ele gerencia apenas o formato. zip enquanto o WinZip suporta vários formatos, incluindo. rar,.arj e. gz. Se você planeja instalar o WinZip, talvez queira desativar a pasta Comprimida, embora os dois se encontrem perfeitamente ao lado da minha máquina. O recurso de pasta compactada é um objeto COM implementado em um arquivo chamado zipfldr. dll. Para cancelar o registro, use o utilitário de sistema regsvr32.exe. A linha de comando que deseja usar para anular o registro é:
regsvr32.exe / u zipfldr. dll.
Obtendo as ferramentas de linha de comando WinZip.
O popular aplicativo WinZip fornece um complemento de linha de comando que oferece a energia e o conforto do WinZip sem a interface gráfica de usuário usual. O add-on é realmente dois executáveis ​​distintos? Wzzip. exe e wzunzip. exe. Faça o download no winzip / wzcline. htm.
Listagem 1: Emulando o Gerenciador de Tarefas do Windows.
Listagem 2: Exibindo a lista de dependências de um processo.
Listagem 3: O método Gzip na classe Compressor.
Listagem 4: os métodos Zip e ReadZip na classe Compressor.
Leonardo Esposito.
Dino Esposito é o autor de "Programação ASP MVC" para a Microsoft Press, bem como "Programação ASP 4" e outros livros mais vendidos, como "Microsoft ®: Arquitetura de Aplicações para a Empresa". Contribuinte regular para o MSDN Magazine e DevProConnections Magazine, a Dino é um orador freqüente em eventos da indústria em todo o mundo, incluindo Microsoft TechED e DevConnections. Após uma década de desenvolvimento na Web, Dino saltou no movimento móvel e está se desenvolvendo ativamente para iOs, Android e WP7.
Este artigo foi arquivado em:
Este artigo foi publicado em:
Tem dúvidas técnicas adicionais?
Obtenha ajuda dos especialistas na revista CODE - inscreva-se para a nossa hora livre de consultoria!