Tratamento de exceções de banco de dados com Try/Catch

VB.NET - Usando a classe System.Diagnostic.Process

Para acompanhar este artigo você precisa saber o que é um processo. O que é um processo ?

Indo direto ao que interessa um processo é simplesmente uma aplicação que esta rodando no seu computador.

Pois bem , agora que você já sabe o que é um processo (os puristas que me desculpem...) , voltemos ao assunto do artigo. Neste artigo eu vou falar sobre a classe Process do namespace System.Diagnostic. Ela pode ser usada para iniciar e parar processos , controlar e monitorar aplicações.

Usando a classe Process você pode obter informações sobre processos e aplicações , pode também usá-la para criar uma instância de uma aplicação ou parar um processo que esta sendo executado. A grosso modo poderíamos dizer que a classe Process é a sucessora do comando Shell do VB6 (lembra dele ?)

Nota: Uma thread (linha de execução) é a unidade básica com a qual o sistema operacional aloca o tempo de processos. Uma thread pode executar qualquer parte do código do processo , incluindo partes que estão sendo atualmente executadas por outra thread.

Obtendo informação do processo atual

Quais informações podemos obter através da classe Process ? A seguir temos uma tabela com a relação dos principais membros da classe Process: (para uma relação completa das propriedades e métodos consulte a documentação)

Propriedades públicas:

BasePriority	Obtêm a base prioritária do processo associado.
Container	Obtêm a IContainer que contém o componente
EnableRaisingEvents	Obtêm ou define se o evento Exited será disparado quando o processo terminar.
ExitCode	Obtêm um valor para o processo associado quando o mesmo é encerrado.
ExitTime	Obtêm a hora que o processo associado encerrou.
Handle	Retorna o handle do processo associado nativo.
HandleCount	Obtêm o número de handles abertos pelo processo.
HasExited	Obtêm um valor indicando se o processo associado terminou.
Id	Obtêm o identificador único para o processo associado.
MachineName	Obtêm o nome do computador no qual o processo associado esta rodando.
MainModule	Obtêm o módulo principal do processo associado.
MainWindowHandle	Obtêm o handle da janela para a janela principal do processo associado.
MainWindowTitle	Obtêm o titulo da janela principal do processo.
ProcessName	Obtêm o nome do processo.
Responding	Obtêm um valor indicando se a interface do usuário do processo esta respondendo
Site	Obtêm ou define o ISite do componente.
StartTime	Obtêm a hora que o processo associado foi iniciado.
Threads	Obtêm o conjunto de threads que estão rodando no processo associado.
TotalProcessorTime	Obtêm a tempo total de processamento para este processo.
UserProcessorTime	Obtêm o tempo de processamento este processo.
VirtualMemrySize	Obtêm o tamanho da memória virtual do processo.
WorkingSet	Obtêm a memória física associada ao processo atual.

Agora vamos ver um exemplo prático onde iremos obter algumas informações do processo na máquina local.

Crie um novo projeto do tipo Console Application e insira o código conforme abaixo:

Imports System.Diagnostics

Module Module1

    Sub Main()

        Dim proc As Process = Process.GetCurrentProcess

        Console.WriteLine("Identificador do processo : " & proc.Id.ToString)

        Console.WriteLine("Nome do Processo: " & proc.ProcessName)

        Console.WriteLine("Handle do processo: " & proc.Handle.ToString)

        Console.WriteLine("Titulo da janela principal do processo : " & proc.MainWindowTitle)

        Console.WriteLine("Informação da base prioritária : " & proc.BasePriority)

        Console.WriteLine("Número de handles abertos pelo processo : " & proc.HandleCount.ToString)

        Console.WriteLine("A interface do usuário esta respondendo ? " & proc.Responding.ToString)

        Console.ReadLine()

    End Sub

End Module

No código acima estou usando o processo atual - GetCurrentProcess - para retornar uma referência para o componente processo das aplicações. O Método GetCurrentProcess é shared (estático) por isto não foi preciso criar uma instância da classe Process. Após obter uma referência para o processo atual estou usando algumas das propriedades da classe para obter informações. O resultado obtido é o seguinte :

Obtendo uma lista dos processos atuais

É uma tarefa simples obter uma relação dos processos rodando no seu sistema. Para isto vamos usar o método estático (shared) GetProcess() ; ele retorna uma Array dos componentes do processo. O código abaixo mostra como fazer isto:

Imports System.Diagnostics

Module Module1

    Sub Main()

        Dim proc As Process

        For Each proc In Process.GetProcesses

            Console.WriteLine("Processo # " & proc.ProcessName)

        Next

        Console.ReadLine()

    End Sub

End Module

O resultado obtido na minha máquina local é :

Iniciando um processo

Vou mostrar agora como iniciar um processo. Para fazer isto vou usar o método estático Start da classe Process. No código abaixo vou iniciar o programa NotePad.exe de três formas diferentes:

Imports System.Diagnostics

Module Module1

    Sub Main()

        Process.Start("notepad.exe")

        Process.Start("notepad.exe", "c:\teste\clientes.txt")

        Process.Start("c:\teste\clientes.txt")

    End Sub

End Module

No código temos :

1- Process.Start("notepad.exe") - inicia uma instância do programa Notepad.exe

2- Process.Start("notepad.exe", "c:\teste\clientes.txt") - inicia uma instância do programa Notepad.exe e abre o arquivo clientes.txt

3- Process.Start("c:\teste\clientes.txt") - inicia uma instância do programa que estiver registrado para abrir arquivos com a extensão txt.

Embora o esquema acima funcione você não tem muito controle sobre os processos. Para isto devemos criar uma instância da classe Process e usar o objeto StartInfo. Ele representa um conjunto de parâmetros usados para iniciar um processo. A única propriedade obrigatória que devemos informar é a propriedade FileName ela indica o nome do processo que queremos iniciar.

A vantagem em usar este objeto é que podemos realizar o tratamento de erros se o arquivo não estiver registrado e podemos saber quando o processo foi encerrado Vejamos como fica o código para iniciar o NotePad.exe :

Imports System.Diagnostics

Module Module1

    Sub Main()

        Dim proc As New Process()

        proc.StartInfo.FileName = "Notepad.exe"

        proc.StartInfo.Arguments = "c:\teste.clientes.txt"

        proc.Start()

    End Sub

End Module

Perceba que primeiro criamos uma instância da classe Process e a seguir definimos o nome do processo que vamos iniciar indicando um argumento pertinente e finalmente iniciamos o processo.

Usando eventos para descobrir quando um processo terminou

A classe Process expõe dois eventos : Disposed : é herdado de Component e Exited : que ocorre quando o processo termina.

Para tratar os eventos primeiro temos que criar um manipulador de eventos que irá ser executado quando o processo terminar. No nosso manipulador vamos escrever as propriedades ExitCode e ExitTime na janela de saída indicando que o processo terminou. O código é o seguinte:

Imports System.Diagnostics

Module Module1

    Sub Main()

        Dim proc As New Process()

        proc.StartInfo.FileName = "Notepad.exe"

        proc.StartInfo.Arguments = "c:\teste\clientes.txt"

         proc.EnableRaisingEvents = True

         AddHandler proc.Exited, AddressOf processoTerminou

        proc.Start()

        Console.ReadLine()

    End Sub

    Private Sub processoTerminou(ByVal sender As Object, ByVal e As EventArgs)

        Dim proc As Process = CType(sender, Process)

        Console.WriteLine("Saiu " & proc.ExitCode)

        Console.WriteLine("Terminou as : " & proc.ExitTime.ToString)

        Console.ReadLine()

    End Sub

End Module

Após criar o manipulador de eventos - processoTerminou() - para sabermos quando o evento foi disparado temos que incluir duas linhas de código antes de iniciar o processo. Devemos definir EnableRaisingEvents como True afim de permitir que evento dispare e precisamos incluir também o tratamento do evento Exited relacionando-o com a rotina - processoTerminou() - que criamos.

O resultado após encerrar o aplicativo será:

Se porventura ocorrer um erro devido ao aplicativo indicado não estar registrado no sistema , a classe Process fornece a janela padrão de erro. Para permitir esta funcionalidade você deve definir a propriedade ErrorDialog como True :

proc.StartInfo.ErrorDialog = True

Por hoje é só. Até o próximo artigo VB.NET