Programação C# I - Monitorando Processos

[itachi kun]

Salve galere , resolvi vim compartilhar algumas coisas que tenho aprendido com um projetinho que ando desenvolvendo.
Nesse primeiro tutorial vou ensinar a criar um programinha básico que consegue monitorar todos os processos que são iniciados e finalizados na sua máquina. Ao contrário do que alguns podem pensar no inicio ele não fica consultando continuamente a lista de processos, e sim é notificado quando algum processo inicia ou termina.
A melhor forma e mais eficaz de se fazer isso é criando um driver em kernel-mode, porém essa forma é um tanto quanto complexa, seria necessário utilizar linguagem C, DDK e etc..no nosso caso vamos utilizar WMI.
Tá, mas o que é WMI??
O WMI (Windows Management Instrumentation) é a infraestrutura para o gerenciamento de dados e operações em sistemas baseados no Windows. Por meio do WMI nós podemos obter várias informações a respeito de todo o hardware e do sistema operacional.
Fonte: arquivodecodigos.net

Bom vamos a prática.
Vamos utilizar o Visual Studio (2005 ou superior). Criar um projeto Console Application. Console Application? Sim isso mesmo, isso será só pra aprender o funcionamento básico, depois vcs podem criar uma aplicação de vcs utilizando recursos mais complexos a partir do que vão aprender aqui. Antes de começar a codificar será necessário 2 coisas: Primeiro referenciar a dll System.Management no nosso projeto, e depois incluí-la no código - Using System.Management;
Todo nosso código vai ficar dentro da função Main mesmo, então vamos por partes:

ManagementEventWatcher watcher; 

Essa é a classe que será responsável por toda monitoração dos eventos de criação e término dos processos.

WqlEventQuery query = 
new WqlEventQuery("__InstanceOperationEvent", 
new TimeSpan(0,0,1), 
"TargetInstance isa \"Win32_Process\""); 

Aqui utilizamos a classe WqlEventQuery, que criará uma espécie de query para consultar as informações que nós queremos. Mas peraí, query, como assim, é sql agora? Não, mas é parecido hehe, imagine como se o Windows tivesse diversas "tabelas" internas sobre diversos tipos de informações de hardware e do seu sistema operacional.
No primeiro parâmetro (__InstanceOperationEvent), indicamos que deve ser monitados os eventos de todos os tipos de operações. No segundo passamos um TimeSpan com intervalo de 1 segundo. E por último indicamos uma condição, dizendo que o nosso alvo é do tipo Win32_Process.

watcher = new ManagementEventWatcher(); 
watcher.Query = query; 
watcher.Start(); 

Bom, aqui nada assustador, instanciamos nossa classe watcher, associamos a query criada e colocamos ela pra funcionar.

while (true) 
{ 
    ManagementBaseObject e = watcher.WaitForNextEvent(); 

    switch (e.ClassPath.ClassName) 
    { 
          case "__InstanceCreationEvent": 
            Console.WriteLine( 
                "Processo {0}:{1} foi criado, caminho: {2}", 
                        ((ManagementBaseObject)e 
                        ["TargetInstance"])["ProcessId"], 
                        ((ManagementBaseObject)e 
                        ["TargetInstance"])["Name"], 
                        ((ManagementBaseObject)e 
                        ["TargetInstance"])["ExecutablePath"]); 
                  break; 
            case "__InstanceDeletionEvent": 
                  Console.WriteLine( 
                        "Processo {0}:{1} foi finalizado, caminho: {2}", 
                        ((ManagementBaseObject)e 
                        ["TargetInstance"])["ProcessId"], 
                        ((ManagementBaseObject)e 
                        ["TargetInstance"])["Name"], 
                        ((ManagementBaseObject)e 
                        ["TargetInstance"])["ExecutablePath"]); 
                  break; 
            case "__InstanceModificationEvent": 
                  continue; 
      } 
} 

Aqui finalmente a parte mais importante do que nós queriamos. Vou explicar melhor o que é tudo isso. Primeiro utilizei um loop infinito while(true). Obviamente essa não é a melhor forma de se fazer isso, pois exige um processamento maior do que gostariamos, mas como já disse antes é só um exemplo básico, depois vcs podem modificar para um Timer ou então uma Thread.

ManagementBaseObject e = watcher.WaitForNextEvent(); 

Essa linha cria um objeto ManagementBaseObject que receberá o retorno da nossa monitoração. O método WaitForNextEvent() fica aguardando até que ocorra algum evento, como a criação ou término de um processo Assim que isso ocorre o resultado retorna para o nosso objeto.
Em seguida fazemos um switch no e.ClassPath.ClassName. Isso nos retorna qual o tipo de evento que ocorreu, se foi a criação, término ou modificação de um processo, no nosso caso só iremos utilizar os 2 primeiros.
__InstanceCreationEvent - Evento disparado quando ocorre a criação de um processo.
__InstanceDeletionEvent - Evento disparado quando ocorre a finalização de um processo.
__InstanceModificationEvent - Evento disparado quando um processo é modificado.

Console.WriteLine( 
    "Processo {0}:{1} foi criado, caminho: {2}", 
          ((ManagementBaseObject)e 
            ["TargetInstance"])["ProcessId"], 
            ((ManagementBaseObject)e 
            ["TargetInstance"])["Name"], 
            ((ManagementBaseObject)e 
            ["TargetInstance"])["ExecutablePath"]); 

E finalmente a informação que esperávamos. A partir do evento que capturamos no switch exibimos a informação no console. Fazemos um cast do tipo ((ManagementBaseObject)e ["TargetInstance"]) com o campo da Win32_Process que queremos.

watcher.Stop(); 
Console.ReadKey(); 

Por fim, fechamos nosso watcher, e terminamos o nosso programa.

O fonte completo fica assim:

using System; 
using System.Management; 

namespace ConsoleApplication1 
{ 
    class Program 
    { 
        static void Main(string[] args) 
        { 
            ManagementEventWatcher watcher; 

            WqlEventQuery query = 
            new WqlEventQuery("__InstanceOperationEvent", 
            new TimeSpan(0,0,1), 
            "TargetInstance isa \"Win32_Process\""); 

            watcher = new ManagementEventWatcher(); 
            watcher.Query = query; 
            watcher.Start(); 

            while (true) 
            { 
                ManagementBaseObject e = watcher.WaitForNextEvent(); 

                switch (e.ClassPath.ClassName) 
                { 
                    case "__InstanceCreationEvent": 
                        Console.WriteLine( 
                                    "Processo {0}:{1} foi criado, caminho: {2}", 
                                    ((ManagementBaseObject)e 
                                    ["TargetInstance"])["ProcessId"], 
                                    ((ManagementBaseObject)e 
                                    ["TargetInstance"])["Name"], 
                                    ((ManagementBaseObject)e 
                                    ["TargetInstance"])["ExecutablePath"]); 
                        break; 
                    case "__InstanceDeletionEvent": 
                        Console.WriteLine( 
                                    "Processo {0}:{1} foi finalizado, caminho: {2}", 
                                    ((ManagementBaseObject)e 
                                    ["TargetInstance"])["ProcessId"], 
                                    ((ManagementBaseObject)e 
                                    ["TargetInstance"])["Name"], 
                                    ((ManagementBaseObject)e 
                                    ["TargetInstance"])["ExecutablePath"]); 
                        break; 
                    case "__InstanceModificationEvent": 
                        continue; 
                } 
            } 
            watcher.Stop(); 
            Console.ReadKey(); 
        } 
    } 
} 

Ainda não completamente satisfeito vc pergunta: Mas só essas informações que dá pra pegar mano?
E eu respondo:
http://msdn.microsoft.com/en-us/libr...=vs.85%29.aspx
Aproveite sem moderação.

Então é isso galere, qualquer dúvida tamo ae pra ajudar, até o próximo e espero que gostem

[R0Dr1g0.]

Bem legal mesmo,eu já conhecia o WMI,e ele em muitos casos é uma mão na roda,e foi bem util na minha certificação Microsoft Technology Associate.
Parabéns e continue contribuindo sempre que possível.
Abraço!

[M4CK]

Fala itachi kun !
Parabéns por compartilhar o conhecimento que está adiquirindo.
Parabéns pelo artigo.

Abraços !