Tutorial: criar um aplicativo de serviço Windows

Artigo
05/10/2023

Aviso

Esta documentação não é para a versão mais recente do Serviço do Windows. Para obter o conteúdo mais recente nos Serviços do Windows usando BackgroundService e o modelo do Serviço de Trabalho, confira:

Este artigo demonstra como criar um aplicativo de serviço Windows no Visual Studio que grava mensagens em um log de eventos.

Criar um serviço

Para começar, crie o projeto e defina os valores necessários para o serviço funcionar corretamente.

No menu Arquivo do Visual Studio, selecione Novo>Projeto (ou pressione Ctrl+Shift+N) para abrir a janela Novo Projeto.
Encontre e selecione o modelo de projeto Serviço Windows (.NET Framework).

Observação

Se o modelo Serviço Windows não for exibido, talvez seja necessário instalar a carga de trabalho Desenvolvimento para desktop com .NET usando o Instalador do Visual Studio.
Em Nome, insira MyNewService e, em seguida, selecione OK.

A guia Design será exibida (Service1.cs [Design] ou Service1.vb [Design]).

O modelo de projeto inclui uma classe de componente denominada Service1 herdada de System.ServiceProcess.ServiceBase. Isso inclui grande parte do código de serviço básico, como o código para iniciar o serviço.

Renomear o serviço

Renomeie o serviço de Service1 para MyNewService.

No Gerenciador de Soluções, selecione Service1.cs ou Service1.vb e escolha Renomear no menu de atalho. Renomeie o arquivo como MyNewService.cs ou MyNewService.vb e, em seguida, pressione Enter

Uma janela pop-up será exibida perguntando se você deseja renomear todas as referências ao elemento de código Service1.
Na janela pop-up, selecione Sim.
Na guia Design, selecione Propriedades no menu de atalho. Na janela Propriedades, altere o valor ServiceName para MyNewService.
Selecione Salvar Tudo no menu Arquivo.

Adicionar recursos ao serviços

Na próxima seção, adicione um log de eventos personalizado ao serviço Windows. O componente EventLog é um exemplo do tipo de componente que pode ser adicionado a um serviço Windows.

Adicionar a funcionalidade de log de eventos personalizado

No Gerenciador de Soluções, no menu de atalho de MyNewService.cs ou MyNewService.vb, escolha Exibir Designer.
Na Caixa de Ferramentas, expanda Componentes e arraste o componente EventLog para a guia Service1.cs [Design] ou Service1.vb [Design].
No Gerenciador de Soluções, no menu de atalho de MyNewService.cs ou MyNewService.vb, escolha Exibir Código.

Defina um log de eventos personalizado.

Em C# , edite o construtor de MyNewService() existente conforme mostrado no trecho de código a seguir. Em Visual Basic, adicione o construtor de New() conforme mostrado no trecho de código a seguir.

public MyNewService()
{
    InitializeComponent();
    eventLog1 = new System.Diagnostics.EventLog();
    if (!System.Diagnostics.EventLog.SourceExists("MySource"))
    {
        System.Diagnostics.EventLog.CreateEventSource(
            "MySource","MyNewLog");
    }
    eventLog1.Source = "MySource";
    eventLog1.Log = "MyNewLog";
}

' To access the constructor in Visual Basic, select New from the
' method name drop-down list. 
Public Sub New()
    MyBase.New()
    InitializeComponent()
    Me.EventLog1 = New System.Diagnostics.EventLog
    If Not System.Diagnostics.EventLog.SourceExists("MySource") Then
        System.Diagnostics.EventLog.CreateEventSource("MySource",
        "MyNewLog")
    End If
    EventLog1.Source = "MySource"
    EventLog1.Log = "MyNewLog"
End Sub

Adicione uma instrução using a MyNewService.cs (caso ela ainda não exista) ou uma instrução Imports para MyNewService.vb para o namespace System.Diagnostics:
```
using System.Diagnostics;
```
```
Imports System.Diagnostics
```
Selecione Salvar Tudo no menu Arquivo.

Definir o que ocorre quando o serviço é iniciado

No editor de código para MyNewService.cs ou MyNewService.vb, localize o método OnStart. O Visual Studio criou automaticamente uma definição de método vazio quando você criou o projeto. Adicione um código que grava uma entrada no log de eventos quando o serviço é iniciado:

protected override void OnStart(string[] args)
{
    eventLog1.WriteEntry("In OnStart.");
}

' To access the OnStart in Visual Basic, select OnStart from the
' method name drop-down list. 
Protected Overrides Sub OnStart(ByVal args() As String)
    EventLog1.WriteEntry("In OnStart")
End Sub

Sondagem

Como um aplicativo de serviço foi projetado para ser de execução longa, ele geralmente sonda ou monitora o sistema, que você configurou no método OnStart. O método OnStart precisa ser retornado ao sistema operacional depois que a operação do serviço é iniciada, de modo que o sistema não seja bloqueado.

Para configurar um mecanismo simples de sondagem, use o componente System.Timers.Timer. O temporizador aciona um evento Elapsed em intervalos regulares, momento em que o serviço pode fazer o monitoramento. Use o componente Timer da seguinte maneira:

Defina as propriedades do componente Timer no método MyNewService.OnStart.
Inicie o temporizador chamando o método Start.

Configure o mecanismo de sondagem

Adicione uma instrução using a MyNewService.cs ou uma instrução Imports a MyNewService.vb para o namespace System.Timers:
```
using System.Timers;
```
```
Imports System.Timers
```

Adicione o seguinte código ao evento MyNewService.OnStart para configurar o mecanismo de sondagem:

// Set up a timer that triggers every minute.
Timer timer = new Timer();
timer.Interval = 60000; // 60 seconds
timer.Elapsed += new ElapsedEventHandler(this.OnTimer);
timer.Start();

' Set up a timer that triggers every minute.
Dim timer As Timer = New Timer()
timer.Interval = 60000 ' 60 seconds
AddHandler timer.Elapsed, AddressOf Me.OnTimer
timer.Start()

Na classe MyNewService, adicione uma variável de membro. Ela contém o identificador do próximo evento a ser gravado no log de eventos:
```
private int eventId = 1;
```
```
Private eventId As Integer = 1
```

Na classe MyNewService, adicione o método OnTimer para manipular o evento Timer.Elapsed:

public void OnTimer(object sender, ElapsedEventArgs args)
{
    // TODO: Insert monitoring activities here.
    eventLog1.WriteEntry("Monitoring the System", EventLogEntryType.Information, eventId++);
}

Private Sub OnTimer(sender As Object, e As Timers.ElapsedEventArgs)
   ' TODO: Insert monitoring activities here.
   eventLog1.WriteEntry("Monitoring the System", EventLogEntryType.Information, eventId)
   eventId = eventId + 1
End Sub

Em vez de executar todo o trabalho no thread principal, você pode executar tarefas usando threads de trabalho em segundo plano. Para obter mais informações, consulte System.ComponentModel.BackgroundWorker.

Definir o que ocorre quando o serviço é interrompido

Insira uma linha de código no método OnStop que adiciona uma entrada ao log de eventos quando o serviço é interrompido:

protected override void OnStop()
{
    eventLog1.WriteEntry("In OnStop.");
}

Protected Overrides Sub OnStop()
    EventLog1.WriteEntry("In OnStop.")
End Sub

Definir outras ações para o serviço

Também é possível substituir os métodos OnPause, OnContinue e OnShutdown para definir o processamento adicional para seu componente.

O seguinte código mostra como substituir o método OnContinue na classe MyNewService:

protected override void OnContinue()
{
    eventLog1.WriteEntry("In OnContinue.");
}

Protected Overrides Sub OnContinue()
    EventLog1.WriteEntry("In OnContinue.")
End Sub

Definir status do serviço

Os serviços relatam seu status para o Gerenciador de Controle de Serviço, de modo que um usuário possa determinar se um serviço está funcionando corretamente. Por padrão, um serviço que herda de ServiceBase relata um conjunto limitado de configurações de status, que incluem SERVICE_STOPPED, SERVICE_PAUSED e SERVICE_RUNNING. Se um serviço leva um tempo para ser inicializado, é útil relatar um status SERVICE_START_PENDING.

Você pode implementar as configurações de status SERVICE_START_PENDING e SERVICE_STOP_PENDING adicionando o código que chama a função SetServiceStatus do Windows.

Implementar o status pendente do serviço

Adicione uma instrução using a MyNewService.cs ou uma instrução Imports a MyNewService.vb para o namespace System.Runtime.InteropServices:
```
using System.Runtime.InteropServices;
```
```
Imports System.Runtime.InteropServices
```

Adicione o seguinte código a MyNewService.cs ou MyNewService.vb para declarar os valores ServiceState e adicionar uma estrutura ao status, que você usará em uma chamada de invocação de plataforma:

public enum ServiceState
{
    SERVICE_STOPPED = 0x00000001,
    SERVICE_START_PENDING = 0x00000002,
    SERVICE_STOP_PENDING = 0x00000003,
    SERVICE_RUNNING = 0x00000004,
    SERVICE_CONTINUE_PENDING = 0x00000005,
    SERVICE_PAUSE_PENDING = 0x00000006,
    SERVICE_PAUSED = 0x00000007,
}

[StructLayout(LayoutKind.Sequential)]
public struct ServiceStatus
{
    public int dwServiceType;
    public ServiceState dwCurrentState;
    public int dwControlsAccepted;
    public int dwWin32ExitCode;
    public int dwServiceSpecificExitCode;
    public int dwCheckPoint;
    public int dwWaitHint;
};

Public Enum ServiceState
    SERVICE_STOPPED = 1
    SERVICE_START_PENDING = 2
    SERVICE_STOP_PENDING = 3
    SERVICE_RUNNING = 4
    SERVICE_CONTINUE_PENDING = 5
    SERVICE_PAUSE_PENDING = 6
    SERVICE_PAUSED = 7
End Enum

<StructLayout(LayoutKind.Sequential)>
Public Structure ServiceStatus
    Public dwServiceType As Long
    Public dwCurrentState As ServiceState
    Public dwControlsAccepted As Long
    Public dwWin32ExitCode As Long
    Public dwServiceSpecificExitCode As Long
    Public dwCheckPoint As Long
    Public dwWaitHint As Long
End Structure

Observação

O Gerenciador de Controle de Serviço usa os membros dwWaitHint e dwCheckpoint da estrutura SERVICE_STATUS para determinar quanto tempo esperar para que um serviço Windows seja iniciado ou desligado. Se os métodos OnStart e OnStop tiverem uma execução longa, o serviço poderá solicitar mais tempo chamando SetServiceStatus novamente com um valor dwCheckPoint incrementado.

Na classe MyNewService, declare a função SetServiceStatus usando a inovação de plataforma:

[DllImport("advapi32.dll", SetLastError = true)]
private static extern bool SetServiceStatus(System.IntPtr handle, ref ServiceStatus serviceStatus);

Declare Auto Function SetServiceStatus Lib "advapi32.dll" (ByVal handle As IntPtr, ByRef serviceStatus As ServiceStatus) As Boolean

Para implementar o status SERVICE_START_PENDING, adicione o seguinte código ao início do método OnStart:

// Update the service state to Start Pending.
ServiceStatus serviceStatus = new ServiceStatus();
serviceStatus.dwCurrentState = ServiceState.SERVICE_START_PENDING;
serviceStatus.dwWaitHint = 100000;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);

' Update the service state to Start Pending.
Dim serviceStatus As ServiceStatus = New ServiceStatus()
serviceStatus.dwCurrentState = ServiceState.SERVICE_START_PENDING
serviceStatus.dwWaitHint = 100000
SetServiceStatus(Me.ServiceHandle, serviceStatus)

Adicione o código ao final do método OnStart para definir o status como SERVICE_RUNNING:

// Update the service state to Running.
serviceStatus.dwCurrentState = ServiceState.SERVICE_RUNNING;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);

' Update the service state to Running.
serviceStatus.dwCurrentState = ServiceState.SERVICE_RUNNING
SetServiceStatus(Me.ServiceHandle, serviceStatus)

(Opcional) Se OnStop for um método de execução longa, repita esse procedimento no método OnStop. Implemente o status SERVICE_STOP_PENDING e retorne o status SERVICE_STOPPED antes da saída do método OnStop.

Por exemplo:

// Update the service state to Stop Pending.
ServiceStatus serviceStatus = new ServiceStatus();
serviceStatus.dwCurrentState = ServiceState.SERVICE_STOP_PENDING;
serviceStatus.dwWaitHint = 100000;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);

// Update the service state to Stopped.
serviceStatus.dwCurrentState = ServiceState.SERVICE_STOPPED;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);

' Update the service state to Stop Pending.
Dim serviceStatus As ServiceStatus = New ServiceStatus()
serviceStatus.dwCurrentState = ServiceState.SERVICE_STOP_PENDING
serviceStatus.dwWaitHint = 100000
SetServiceStatus(Me.ServiceHandle, serviceStatus)

' Update the service state to Stopped.
serviceStatus.dwCurrentState = ServiceState.SERVICE_STOPPED
SetServiceStatus(Me.ServiceHandle, serviceStatus)

Adicionar instaladores ao serviço

Antes de executar um serviço Windows, é necessário instalá-lo, o que o registra no Gerenciador de Controle de Serviço. Adicione instaladores ao projeto para lidar com os detalhes de registro.

No Gerenciador de Soluções, no menu de atalho de MyNewService.cs ou MyNewService.vb, escolha Designer de Exibição.
Na exibição Design, selecione a área em segundo plano e, em seguida, escolha Adicionar Instalador no menu de atalho.

Por padrão, o Visual Studio adiciona uma classe de componente chamada ProjectInstaller, que contém dois instaladores, ao projeto. Esses instaladores destinam-se ao serviço e ao processo associado do serviço.
Na exibição Design de ProjectInstaller, selecione serviceInstaller1 para um projeto do Visual C# ou ServiceInstaller1 para um projeto do Visual Basic e, em seguida, escolha Propriedades no menu de atalho.
Na janela Propriedades, verifique se a propriedade ServiceName está definida como MyNewService.
Adicione um texto à propriedade Description, como Um serviço de exemplo.

Esse texto é exibido na coluna Descrição da janela Serviços e descreve o serviço para o usuário.
Adicione o texto à propriedade DisplayName. Por exemplo, Nome de Exibição do MyNewService.

Esse texto é exibido na coluna Nome de Exibição da janela Serviços. Esse nome pode ser diferente da propriedade ServiceName, que é o nome usado pelo sistema (por exemplo, o nome usado para o comando net start para iniciar o serviço).
Defina a propriedade StartType como Automatic na lista suspensa.
Quando terminar, as janelas Propriedades deverão ser semelhantes à seguinte figura:
Na exibição Design de ProjectInstaller, escolha serviceProcessInstaller1 para um projeto do Visual C# ou ServiceProcessInstaller1 para um projeto do Visual Basic e, em seguida, escolha Propriedades no menu de atalho. Defina a propriedade Account como LocalSystem na lista suspensa.

Essa configuração instala o serviço e o executa usando a conta Sistema Local.

Importante

A conta LocalSystem tem amplas permissões, incluindo a capacidade de gravar no log de eventos. Use essa conta com cuidado, pois ela pode aumentar o risco de ataques de software mal-intencionado. Para outras tarefas, pense em usar a conta LocalService, que atua como um usuário não privilegiado no computador local e apresenta credenciais anônimas a qualquer servidor remoto. Este exemplo falhará se você tentar usar a conta LocalService, pois ele precisa de permissão para gravar no log de eventos.

Para saber mais sobre instaladores, confira Como adicionar instaladores ao aplicativo de serviço.

(Opcional) Defina os parâmetros de inicialização

Observação

Antes de decidir adicionar parâmetros de inicialização, considere se esta é a melhor maneira de passar informações para o serviço. Embora elas sejam fáceis de serem usadas e analisadas e um usuário possa substituí-las com facilidade, elas podem ser mais difíceis para um usuário descobrir e usá-las sem a documentação. Em geral, se o serviço exigir mais do que apenas alguns parâmetros de inicialização, você deverá usar o Registro ou um arquivo de configuração.

Um serviço Windows pode aceitar argumentos de linha de comando ou parâmetros de inicialização. Quando você adiciona um código aos parâmetros de inicialização do processo, um usuário pode iniciar o serviço com seus próprios parâmetros de inicialização personalizados na janela Propriedades do serviço. No entanto, esses parâmetros de inicialização não são persistentes na próxima vez que o serviço é iniciado. Para definir parâmetros de inicialização permanentemente, defina-os no Registro.

Cada serviço Windows tem uma entrada do Registro na subchave HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services. Na subchave de cada serviço, use a subchave Parâmetros para armazenar informações que o serviço pode acessar. É possível usar arquivos de configuração de aplicativo para um serviço Windows da mesma forma que faz para outros tipos de programas. Para obter um código de exemplo, confira ConfigurationManager.AppSettings.

Para adicionar parâmetros de inicialização

Selecione Program.cs ou MyNewService.Designer.vb e, em seguida, escolha Exibir Código no menu de atalho. No método Main, altere o código para adicionar um parâmetro de entrada e passá-lo para o construtor do serviço:

static void Main(string[] args)
{
    ServiceBase[] ServicesToRun;
    ServicesToRun = new ServiceBase[]
    {
        new MyNewService(args)
    };
    ServiceBase.Run(ServicesToRun);
}

Shared Sub Main(ByVal cmdArgs() As String)
    Dim ServicesToRun() As System.ServiceProcess.ServiceBase = New System.ServiceProcess.ServiceBase() {New MyNewService(cmdArgs)}
    System.ServiceProcess.ServiceBase.Run(ServicesToRun)
End Sub

Em MyNewService.cs ou MyNewService.vb, altere o construtor MyNewService para processar o parâmetro de entrada da seguinte maneira:

using System.Diagnostics;

public MyNewService(string[] args)
{
    InitializeComponent();

    string eventSourceName = "MySource";
    string logName = "MyNewLog";

    if (args.Length > 0)
    {
       eventSourceName = args[0];
    }

    if (args.Length > 1)
    {
        logName = args[1];
    }

    eventLog1 = new EventLog();

    if (!EventLog.SourceExists(eventSourceName))
    {
        EventLog.CreateEventSource(eventSourceName, logName);
    }

    eventLog1.Source = eventSourceName;
    eventLog1.Log = logName;
}

Imports System.Diagnostics

Public Sub New(ByVal cmdArgs() As String)
    InitializeComponent()
    Dim eventSourceName As String = "MySource"
    Dim logName As String = "MyNewLog"
    If (cmdArgs.Count() > 0) Then
        eventSourceName = cmdArgs(0)
    End If
    If (cmdArgs.Count() > 1) Then
        logName = cmdArgs(1)
    End If
    eventLog1 = New EventLog()
    If (Not EventLog.SourceExists(eventSourceName)) Then
        EventLog.CreateEventSource(eventSourceName, logName)
    End If
    eventLog1.Source = eventSourceName
    eventLog1.Log = logName
End Sub

Esse código define o nome do log e da origem do evento, de acordo com os parâmetros de inicialização fornecidos pelo usuário. Se nenhum argumento for fornecido, ele usará valores padrão.

Para especificar os argumentos de linha de comando, adicione o seguinte código à classe ProjectInstaller em ProjectInstaller.cs ou ProjectInstaller.vb:
```
protected override void OnBeforeInstall(IDictionary savedState)
{
    string parameter = "MySource1\" \"MyLogFile1";
    Context.Parameters["assemblypath"] = "\"" + Context.Parameters["assemblypath"] + "\" \"" + parameter + "\"";
    base.OnBeforeInstall(savedState);
}
```
```
Protected Overrides Sub OnBeforeInstall(ByVal savedState As IDictionary)
    Dim parameter As String = "MySource1"" ""MyLogFile1"
    Context.Parameters("assemblypath") = """" + Context.Parameters("assemblypath") + """ """ + parameter + """"
    MyBase.OnBeforeInstall(savedState)
End Sub
```
Normalmente, esse valor contém o caminho completo para o executável do serviço Windows. Para que o serviço seja iniciado corretamente, o usuário precisará inserir aspas no caminho e em cada parâmetro individual. Um usuário pode alterar os parâmetros na entrada do Registro ImagePath para alterar os parâmetros de inicialização do serviço Windows. No entanto, uma maneira melhor é alterar o valor de forma programática e expor a funcionalidade de forma amigável, como por meio de um utilitário de configuração ou gerenciamento.

Compilar o serviço

No Gerenciador de Soluções, escolha Propriedades no menu de atalho do projeto MyNewService.

As páginas de propriedades do seu projeto aparecem.
Na guia Aplicativo, na lista Objeto de inicialização, escolha MyNewService.Program ou Sub Main para projetos do Visual Basic.
Para compilar o projeto, no Gerenciador de Soluções, escolha Compilar no menu de atalho do projeto (ou pressione Ctrl+Shift+B).

Instalar o serviço

Agora que você criou o serviço Windows, poderá instalá-lo. Para instalar um serviço Windows, é necessário ter credenciais de administrador no computador no qual ele é instalado.

Abra o Prompt de Comando do Desenvolvedor para Visual Studio com credenciais administrativas.
Em Prompt de Comando do Desenvolvedor para Visual Studio, navegue para a pasta que contém a saída do projeto (por padrão, o subdiretório \bin\Debug do projeto).
Digite o seguinte comando:
```
installutil MyNewService.exe
```
Se o serviço for instalado com êxito, o comando relatará o êxito.

Se o sistema não puder localizar installutil.exe, verifique se ele existe no computador. Essa ferramenta é instalada com o .NET Framework na pasta %windir%\Microsoft.NET\Framework[64]<>versão do Framework. Por exemplo, o caminho padrão da versão de 64 bits é %windir%\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe.

Se o processo installutil.exe falhar, verifique o log de instalação para saber o motivo. Por padrão, o log está localizado na mesma pasta do executável do serviço. A instalação poderá falhar se:
- A classe RunInstallerAttribute não estiver presente na classe ProjectInstaller.
- O atributo não estiver definido como true.
- A classe ProjectInstaller não estiver definida como public.

Para saber mais, confira Como instalar e desinstalar serviços.

Iniciar e executar o serviço

No Windows, abra o aplicativo da área de trabalho Serviços. Pressione Windows+R para abrir a caixa Executar, insira services.msc e, em seguida, pressione Enter ou selecione OK.

Você deve ver o serviço listado em Serviços, exibido em ordem alfabética pelo nome de exibição definido para ele.
Para iniciar o serviço, escolha Iniciar no menu de atalho do serviço.
Para interromper o serviço, escolha Parar no menu de atalho do serviço.
(Opcional) Na linha de comando, use os comandos net start <nome do serviço> e net stop <nome do serviço> para iniciar e parar o serviço.

Verificar a saída do log de eventos do seu serviço

No Windows, abra o aplicativo da área de trabalho Visualizador de Eventos. Insira Visualizador de Eventos na barra de pesquisa do Windows e, em seguida, selecione Visualizador de Eventos nos resultados da pesquisa.

Dica

No Visual Studio, é possível acessar logs de eventos abrindo Gerenciador de Servidores do menu Exibir (ou pressione Ctrl+Alt+S) e expandindo o nó Logs de Eventos no computador local.
No Visualizador de Eventos, expanda Logs de Aplicativos e Serviços.
Localize a listagem de MyNewLog (ou MyLogFile1, se você seguiu o procedimento para adicionar argumentos de linha de comando) e expanda-a. Você deverá ver as entradas para as duas ações (iniciar e parar) executadas pelo serviço.

Limpar recursos

Caso não precise mais do aplicativo serviço Windows, remova-o.

Abra o Prompt de Comando do Desenvolvedor para Visual Studio com credenciais administrativas.
Na janela Prompt de Comando do Desenvolvedor para Visual Studio, navegue para a pasta que contém a saída do projeto.
Digite o seguinte comando:
```
installutil.exe /u MyNewService.exe
```
Se o serviço for desinstalado com êxito, o comando relatará que o serviço foi removido com sucesso. Para saber mais, confira Como instalar e desinstalar serviços.

Próximas etapas

Agora que você criou o serviço, você poderá:

Criar um programa de instalação autônoma para que outros possam usá-lo para instalar o serviço Windows. Usar o Conjunto de ferramentas do WiX para criar um instalador para um serviço Windows. Para ver outras ideias, confira Create an installer package (Criar um pacote do instalador).
Explorar o componente ServiceController, que permite enviar comandos ao serviço instalado.
Em vez de criar o log de eventos quando o aplicativo é executado, use um instalador para criar um log de eventos ao instalar o aplicativo. O log de eventos é excluído pelo instalador quando você desinstala o aplicativo. Para obter mais informações, consulte EventLogInstaller.