Tutorial: Criar um aplicativo de serviço WindowsTutorial: Create a Windows service app

Este artigo demonstra como criar um aplicativo de serviço Windows no Visual Studio que grava mensagens em um log de eventos.This article demonstrates how to create a Windows service app in Visual Studio that writes messages to an event log.

Criar um serviçoCreate a service

Para começar, crie o projeto e defina os valores necessários para o serviço funcionar corretamente.To begin, create the project and set the values that are required for the service to function correctly.

  1. No menu Arquivo do Visual Studio, selecione Novo > Projeto (ou pressione Ctrl+Shift+N) para abrir a janela Novo Projeto.From the Visual Studio File menu, select New > Project (or press Ctrl+Shift+N) to open the New Project window.

  2. Navegue para o modelo de projeto Serviço Windows (.NET Framework) e selecione-o.Navigate to and select the Windows Service (.NET Framework) project template. Para encontrá-lo, expanda Instalados e Visual C# ou Visual Basic e, em seguida, selecione Windows Desktop.To find it, expand Installed and Visual C# or Visual Basic, then select Windows Desktop. Se preferir, insira Serviço Windows na caixa de pesquisa no canto superior direito e pressione Enter.Or, enter Windows Service in the search box on the upper right and press Enter.

    Modelo de Serviço Windows na caixa de diálogo Novo Projeto no Visual Studio

    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:If you don't see the Windows Service template, you may need to install the .NET desktop development workload:

    Na caixa de diálogo Novo Projeto, selecione Abrir Instalador do Visual Studio na parte inferior esquerda.In the New Project dialog, select Open Visual Studio Installer on the lower left. Selecione a carga de trabalho Desenvolvimento para desktop com .NET e, em seguida, selecione Modificar.Select the .NET desktop development workload, and then select Modify.

  3. Em Nome, insira MyNewService e, em seguida, selecione OK.For Name, enter MyNewService, and then select OK.

    A guia Design será exibida (Service1.cs [Design] ou Service1.vb [Design]).The Design tab appears (Service1.cs [Design] or Service1.vb [Design]).

    O modelo de projeto inclui uma classe de componente denominada Service1 herdada de System.ServiceProcess.ServiceBase.The project template includes a component class named Service1 that inherits from System.ServiceProcess.ServiceBase. Isso inclui grande parte do código de serviço básico, como o código para iniciar o serviço.It includes much of the basic service code, such as the code to start the service.

Renomear o serviçoRename the service

Renomeie o serviço de Service1 para MyNewService.Rename the service from Service1 to MyNewService.

  1. No Gerenciador de Soluções, selecione Service1.cs ou Service1.vb e escolha Renomear no menu de atalho.In Solution Explorer, select Service1.cs, or Service1.vb, and choose Rename from the shortcut menu. Renomeie o arquivo como MyNewService.cs ou MyNewService.vb e, em seguida, pressione EnterRename the file to MyNewService.cs, or MyNewService.vb, and then press Enter

    Uma janela pop-up será exibida perguntando se você deseja renomear todas as referências ao elemento de código Service1.A pop-up window appears asking whether you would like to rename all references to the code element Service1.

  2. Na janela pop-up, selecione Sim.In the pop-up window, select Yes.

    Prompt RenomearRename prompt

  3. Na guia Design, selecione Propriedades no menu de atalho.In the Design tab, select Properties from the shortcut menu. Na janela Propriedades, altere o valor ServiceName para MyNewService.From the Properties window, change the ServiceName value to MyNewService.

    Propriedades do serviçoService properties

  4. Selecione Salvar Tudo no menu Arquivo.Select Save All from the File menu.

Adicionar recursos ao serviçosAdd features to the service

Na próxima seção, adicione um log de eventos personalizado ao serviço Windows.In this section, you add a custom event log to the Windows service. O componente EventLog é um exemplo do tipo de componente que pode ser adicionado a um serviço Windows.The EventLog component is an example of the type of component you can add to a Windows service.

Adicionar a funcionalidade de log de eventos personalizadoAdd custom event log functionality

  1. No Gerenciador de Soluções, no menu de atalho de MyNewService.cs ou MyNewService.vb, escolha Designer de Exibição.In Solution Explorer, from the shortcut menu for MyNewService.cs, or MyNewService.vb, choose View Designer.

  2. Na Caixa de Ferramentas, expanda Componentes e, em seguida, arraste o componente EventLog para a guia Service1.cs [Design] ou Service1.vb [Design].In Toolbox, expand Components, and then drag the EventLog component to the Service1.cs [Design], or Service1.vb [Design] tab.

  3. No Gerenciador de Soluções, no menu de atalho de MyNewService.cs ou MyNewService.vb, escolha Exibir Código.In Solution Explorer, from the shortcut menu for MyNewService.cs, or MyNewService.vb, choose View Code.

  4. Defina um log de eventos personalizado.Define a custom event log. Para o C#, edite o construtor MyNewService() existente; para o Visual Basic, adicione o construtor New():For C#, edit the existing MyNewService() constructor; for Visual Basic, add the New() constructor:

    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
    
  5. Adicione uma instrução using a MyNewService.cs (caso ela ainda não exista) ou uma instrução Imports a MyNewService.vb para o namespace System.Diagnostics:Add a using statement to MyNewService.cs (if it doesn't already exist), or an Imports statement MyNewService.vb, for the System.Diagnostics namespace:

    using System.Diagnostics;
    
    Imports System.Diagnostics
    
  6. Selecione Salvar Tudo no menu Arquivo.Select Save All from the File menu.

Definir o que ocorre quando o serviço é iniciadoDefine what occurs when the service starts

No editor de códigos de MyNewService.cs ou MyNewService.vb, localize o método OnStart; o Visual Studio criou automaticamente uma definição de método vazia quando você criou o projeto.In the code editor for MyNewService.cs or MyNewService.vb, locate the OnStart method; Visual Studio automatically created an empty method definition when you created the project. Adicione um código que grava uma entrada no log de eventos quando o serviço é iniciado:Add code that writes an entry to the event log when the service starts:

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

SondagemPolling

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.Because a service application is designed to be long-running, it usually polls or monitors the system, which you set up in the OnStart method. 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.The OnStart method must return to the operating system after the service's operation has begun so that the system isn't blocked.

Para configurar um mecanismo simples de sondagem, use o componente System.Timers.Timer.To set up a simple polling mechanism, use the System.Timers.Timer component. O temporizador aciona um evento Elapsed em intervalos regulares, momento em que o serviço pode fazer o monitoramento.The timer raises an Elapsed event at regular intervals, at which time your service can do its monitoring. Use o componente Timer da seguinte maneira:You use the Timer component as follows:

  • Defina as propriedades do componente Timer no método MyNewService.OnStart.Set the properties of the Timer component in the MyNewService.OnStart method.
  • Inicie o temporizador chamando o método Start.Start the timer by calling the Start method.
Configure o mecanismo de sondagem.Set up the polling mechanism.
  1. Adicione o seguinte código ao evento MyNewService.OnStart para configurar o mecanismo de sondagem:Add the following code in the MyNewService.OnStart event to set up the polling mechanism:

    // 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()
    
  2. Adicione uma instrução using a MyNewService.cs ou uma instrução Imports a MyNewService.vb para o namespace System.Timers:Add a using statement to MyNewService.cs, or an Imports statement to MyNewService.vb, for the System.Timers namespace:

    using System.Timers;
    
    Imports System.Timers
    
  3. Na classe MyNewService, adicione o método OnTimer para manipular o evento Timer.Elapsed:In the MyNewService class, add the OnTimer method to handle the Timer.Elapsed event:

    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
    
  4. Na classe MyNewService, adicione uma variável de membro.In the MyNewService class, add a member variable. Ela contém o identificador do próximo evento a ser gravado no log de eventos:It contains the identifier of the next event to write into the event log:

    private int eventId = 1;
    
    Private eventId As Integer = 1
    

Em vez de executar todo o trabalho no thread principal, você pode executar tarefas usando threads de trabalho em segundo plano.Instead of running all your work on the main thread, you can run tasks by using background worker threads. Para obter mais informações, consulte System.ComponentModel.BackgroundWorker.For more information, see System.ComponentModel.BackgroundWorker.

Definir o que ocorre quando o serviço é interrompidoDefine what occurs when the service is stopped

Insira uma linha de código no método OnStop que adiciona uma entrada ao log de eventos quando o serviço é interrompido:Insert a line of code in the OnStop method that adds an entry to the event log when the service is stopped:

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çoDefine other actions for the service

Também é possível substituir os métodos OnPause, OnContinue e OnShutdown para definir o processamento adicional para seu componente.You can override the OnPause, OnContinue, and OnShutdown methods to define additional processing for your component.

O seguinte código mostra como substituir o método OnContinue na classe MyNewService:The following code shows how you to override the OnContinue method in the MyNewService class:

protected override void OnContinue()
{
    eventLog1.WriteEntry("In OnContinue.");
}  
Protected Overrides Sub OnContinue()
    EventLog1.WriteEntry("In OnContinue.")
End Sub

Definir status do serviçoSet service status

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.Services report their status to the Service Control Manager so that a user can tell whether a service is functioning correctly. 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.By default, a service that inherits from ServiceBase reports a limited set of status settings, which include SERVICE_STOPPED, SERVICE_PAUSED, and SERVICE_RUNNING. Se um serviço leva um tempo para ser inicializado, é útil relatar um status SERVICE_START_PENDING.If a service takes a while to start up, it's useful to report a SERVICE_START_PENDING status.

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.You can implement the SERVICE_START_PENDING and SERVICE_STOP_PENDING status settings by adding code that calls the Windows SetServiceStatus function.

Implementar o status pendente do serviçoImplement service pending status

  1. Adicione uma instrução using a MyNewService.cs ou uma instrução Imports a MyNewService.vb para o namespace System.Runtime.InteropServices:Add a using statement to MyNewService.cs, or an Imports statement to MyNewService.vb, for the System.Runtime.InteropServices namespace:

    using System.Runtime.InteropServices;
    
    Imports System.Runtime.InteropServices
    
  2. 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:Add the following code to MyNewService.cs, or MyNewService.vb, to declare the ServiceState values and to add a structure for the status, which you'll use in a platform invoke call:

    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 aguardar um serviço Windows ser iniciado ou desligado.The Service Control Manager uses the dwWaitHint and dwCheckpoint members of the SERVICE_STATUS structure to determine how much time to wait for a Windows service to start or shut down. 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.If your OnStart and OnStop methods run long, your service can request more time by calling SetServiceStatus again with an incremented dwCheckPoint value.

  3. Na classe MyNewService, declare a função SetServiceStatus usando a inovação de plataforma:In the MyNewService class, declare the SetServiceStatus function by using platform invoke:

    [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
    
  4. Para implementar o status SERVICE_START_PENDING, adicione o seguinte código ao início do método OnStart:To implement the SERVICE_START_PENDING status, add the following code to the beginning of the OnStart method:

    // 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)
    
  5. Adicione o código ao final do método OnStart para definir o status como SERVICE_RUNNING:Add code to the end of the OnStart method to set the status to 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)
    
  6. (Opcional) Se OnStop for um método de execução longa, repita esse procedimento no método OnStop.(Optional) If OnStop is a long-running method, repeat this procedure in the OnStop method. Implemente o status SERVICE_STOP_PENDING e retorne o status SERVICE_STOPPED antes da saída do método OnStop.Implement the SERVICE_STOP_PENDING status and return the SERVICE_STOPPED status before the OnStop method exits.

    Por exemplo:For example:

    // 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çoAdd installers to the service

Antes de executar um serviço Windows, é necessário instalá-lo, o que o registra no Gerenciador de Controle de Serviço.Before you run a Windows service, you need to install it, which registers it with the Service Control Manager. Adicione instaladores ao projeto para lidar com os detalhes de registro.Add installers to your project to handle the registration details.

  1. No Gerenciador de Soluções, no menu de atalho de MyNewService.cs ou MyNewService.vb, escolha Designer de Exibição.In Solution Explorer, from the shortcut menu for MyNewService.cs, or MyNewService.vb, choose View Designer.

  2. Na exibição Design, selecione a área em segundo plano e, em seguida, escolha Adicionar Instalador no menu de atalho.In the Design view, select the background area, then choose Add Installer from the shortcut menu.

    Por padrão, o Visual Studio adiciona uma classe de componente chamada ProjectInstaller, que contém dois instaladores, ao projeto.By default, Visual Studio adds a component class named ProjectInstaller, which contains two installers, to your project. Esses instaladores destinam-se ao serviço e ao processo associado do serviço.These installers are for your service and for the service's associated process.

  3. 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.In the Design view for ProjectInstaller, select serviceInstaller1 for a Visual C# project, or ServiceInstaller1 for a Visual Basic project, then choose Properties from the shortcut menu.

  4. Na janela Propriedades, verifique se a propriedade ServiceName está definida como MyNewService.In the Properties window, verify the ServiceName property is set to MyNewService.

  5. Adicione um texto à propriedade Description, como Um serviço de exemplo.Add text to the Description property, such as A sample service.

    Esse texto é exibido na coluna Descrição da janela Serviços e descreve o serviço para o usuário.This text appears in the Description column of the Services window and describes the service to the user.

    Descrição do serviço na janela Serviços.Service description in the Services window.

  6. Adicione o texto à propriedade DisplayName.Add text to the DisplayName property. Por exemplo, Nome de Exibição do MyNewService.For example, MyNewService Display Name.

    Esse texto é exibido na coluna Nome de Exibição da janela Serviços.This text appears in the Display Name column of the Services window. 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).This name can be different from the ServiceName property, which is the name the system uses (for example, the name you use for the net start command to start your service).

  7. Defina a propriedade StartType como Automatic na lista suspensa.Set the StartType property to Automatic from the drop-down list.

  8. Quando terminar, as janelas Propriedades deverão ser semelhantes à seguinte figura:When you're finished, the Properties windows should look like the following figure:

    Propriedades do instalador para um serviço WindowsInstaller Properties for a Windows service

  9. 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.In the Design view for ProjectInstaller, choose serviceProcessInstaller1 for a Visual C# project, or ServiceProcessInstaller1 for a Visual Basic project, then choose Properties from the shortcut menu. Defina a propriedade Account como LocalSystem na lista suspensa.Set the Account property to LocalSystem from the drop-down list.

    Essa configuração instala o serviço e o executa usando a conta Sistema Local.This setting installs the service and runs it by using the local system account.

    Importante

    A conta LocalSystem tem amplas permissões, incluindo a capacidade de gravar no log de eventos.The LocalSystem account has broad permissions, including the ability to write to the event log. Use essa conta com cuidado, pois ela pode aumentar o risco de ataques de software mal-intencionado.Use this account with caution, because it might increase your risk of attacks from malicious software. 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.For other tasks, consider using the LocalService account, which acts as a non-privileged user on the local computer and presents anonymous credentials to any remote server. Este exemplo falhará se você tentar usar a conta LocalService, pois ele precisa de permissão para gravar no log de eventos.This example fails if you try to use the LocalService account, because it needs permission to write to the event log.

Para saber mais sobre os instaladores, consulte Como Adicionar instaladores ao aplicativo de serviço.For more information about installers, see How to: Add installers to your service application.

(Opcional) Defina os parâmetros de inicialização(Optional) Set startup parameters

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.Before you decide to add startup parameters, consider whether it's the best way to pass information to your service. 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.Although they're easy to use and parse, and a user can easily override them, they might be harder for a user to discover and use without documentation. 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.Generally, if your service requires more than just a few startup parameters, you should use the registry or a configuration file instead.

Um serviço Windows pode aceitar argumentos de linha de comando ou parâmetros de inicialização.A Windows service can accept command-line arguments, or startup parameters. 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.When you add code to process startup parameters, a user can start your service with their own custom startup parameters in the service properties window. No entanto, esses parâmetros de inicialização não são persistentes na próxima vez que o serviço é iniciado.However, these startup parameters aren't persisted the next time the service starts. Para definir parâmetros de inicialização permanentemente, defina-os no Registro.To set startup parameters permanently, set them in the registry.

Cada serviço Windows tem uma entrada do Registro na subchave HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services.Each Windows service has a registry entry under the HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services subkey. Na subchave de cada serviço, use a subchave Parâmetros para armazenar informações que o serviço pode acessar.Under each service's subkey, use the Parameters subkey to store information that your service can access. É possível usar arquivos de configuração de aplicativo para um serviço Windows da mesma forma que faz para outros tipos de programas.You can use application configuration files for a Windows service the same way you do for other types of programs. Para obter um código de exemplo, confira ConfigurationManager.AppSettings.For sample code, see ConfigurationManager.AppSettings.

Para adicionar parâmetros de inicializaçãoTo add startup parameters

  1. Selecione Program.cs ou MyNewService.Designer.vb e, em seguida, escolha Exibir Código no menu de atalho.Select Program.cs, or MyNewService.Designer.vb, then choose View Code from the shortcut menu. No método Main, altere o código para adicionar um parâmetro de entrada e passá-lo para o construtor do serviço:In the Main method, change the code to add an input parameter and pass it to the service constructor:

    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
    
  2. Em MyNewService.cs ou MyNewService.vb, altere o construtor MyNewService para processar o parâmetro de entrada da seguinte maneira:In MyNewService.cs, or MyNewService.vb, change the MyNewService constructor to process the input parameter as follows:

    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.This code sets the event source and log name according to the startup parameters that the user supplies. Se nenhum argumento for fornecido, ele usará valores padrão.If no arguments are supplied, it uses default values.

  3. Para especificar os argumentos de linha de comando, adicione o seguinte código à classe ProjectInstaller em ProjectInstaller.cs ou ProjectInstaller.vb:To specify the command-line arguments, add the following code to the ProjectInstaller class in ProjectInstaller.cs, or 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.Typically, this value contains the full path to the executable for the Windows service. Para que o serviço seja iniciado corretamente, o usuário precisará inserir aspas no caminho e em cada parâmetro individual.For the service to start up correctly, the user must supply quotation marks for the path and each individual parameter. 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.A user can change the parameters in the ImagePath registry entry to change the startup parameters for the Windows service. 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.However, a better way is to change the value programmatically and expose the functionality in a user-friendly way, such as by using a management or configuration utility.

Compilar o serviçoBuild the service

  1. No Gerenciador de Soluções, escolha Propriedades no menu de atalho do projeto MyNewService.In Solution Explorer, choose Properties from the shortcut menu for the MyNewService project.

    As páginas de propriedades do seu projeto aparecem.The property pages for your project appear.

  2. Na guia Aplicativo, na lista Objeto de inicialização, escolha MyNewService.Program ou Sub Main para projetos do Visual Basic.On the Application tab, in the Startup object list, choose MyNewService.Program, or Sub Main for Visual Basic projects.

  3. Para compilar o projeto, no Gerenciador de Soluções, escolha Compilar no menu de atalho do projeto (ou pressione Ctrl+Shift+B).To build the project, in Solution Explorer, choose Build from the shortcut menu for your project (or press Ctrl+Shift+B).

Instalar o serviçoInstall the service

Agora que você criou o serviço Windows, poderá instalá-lo.Now that you've built the Windows service, you can install it. Para instalar um serviço Windows, é necessário ter credenciais de administrador no computador no qual ele é instalado.To install a Windows service, you must have administrator credentials on the computer where it's installed.

  1. Abra o Prompt de Comando do Desenvolvedor para Visual Studio com credenciais administrativas.Open Developer Command Prompt for Visual Studio with administrative credentials. No menu Iniciar do Windows, selecione Prompt de Comando do Desenvolvedor para VS 2017 na pasta Visual Studio e, em seguida, selecione Mais > Executar como Administrador no menu de atalho.From the Windows Start menu, select Developer Command Prompt for VS 2017 in the Visual Studio folder, then select More > Run as Administrator from the shortcut menu.

  2. Na janela 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).In the Developer Command Prompt for Visual Studio window, navigate to the folder that contains your project's output (by default, the \bin\Debug subdirectory of your project).

  3. Insira o seguinte comando:Enter the following command:

    installutil MyNewService.exe
    

    Se o serviço for instalado com êxito, o comando relatará o êxito.If the service installs successfully, the command reports success.

    Se o sistema não puder localizar installutil.exe, verifique se ele existe no computador.If the system can't find installutil.exe, make sure that it exists on your computer. Essa ferramenta é instalada com o .NET Framework na pasta %windir%\Microsoft.NET\Framework[64]\<versão do Framework>.This tool is installed with the .NET Framework to the folder %windir%\Microsoft.NET\Framework[64]\<framework version>. Por exemplo, o caminho padrão da versão de 64 bits é %windir%\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe.For example, the default path for the 64-bit version is %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.If the installutil.exe process fails, check the install log to find out why. Por padrão, o log está localizado na mesma pasta do executável do serviço.By default, the log is in the same folder as the service executable. A instalação poderá falhar se:The installation can fail if:

    • A classe RunInstallerAttribute não estiver presente na classe ProjectInstaller.The RunInstallerAttribute class isn't present on the ProjectInstaller class.
    • O atributo não estiver definido como true.The attribute isn't set to true.
    • A classe ProjectInstaller não estiver definida como public.The ProjectInstaller class isn't defined as public.

Para obter mais informações, confira Como: Instalar e desinstalar serviços.For more information, see How to: Install and uninstall services.

Iniciar e executar o serviçoStart and run the service

  1. No Windows, abra o aplicativo da área de trabalho Serviços.In Windows, open the Services desktop app. Pressione Windows+R para abrir a caixa Executar, insira services.msc e, em seguida, pressione Enter ou selecione OK.Press Windows+R to open the Run box, enter services.msc, and then press Enter or select OK.

    Você deve ver o serviço listado em Serviços, exibido em ordem alfabética pelo nome de exibição definido para ele.You should see your service listed in Services, displayed alphabetically by the display name that you set for it.

    MyNewService na janela Serviços.

  2. Para iniciar o serviço, escolha Iniciar no menu de atalho do serviço.To start the service, choose Start from the service's shortcut menu.

  3. Para interromper o serviço, escolha Parar no menu de atalho do serviço.To stop the service, choose Stop from the service's shortcut menu.

  4. (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.(Optional) From the command line, use the commands net start <service name> and net stop <service name> to start and stop your service.

Verificar a saída do log de eventos do seu serviçoVerify the event log output of your service

  1. No Windows, abra o aplicativo da área de trabalho Visualizador de Eventos.In Windows, open the Event Viewer desktop app. Insira Visualizador de Eventos na barra de pesquisa do Windows e, em seguida, selecione Visualizador de Eventos nos resultados da pesquisa.Enter Event Viewer in the Windows search bar, and then select Event Viewer from the search results.

    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.In Visual Studio, you can access event logs by opening Server Explorer from the View menu (or press Ctrl+Alt+S) and expanding the Event Logs node for the local computer.

  2. No Visualizador de Eventos, expanda Logs de Aplicativos e Serviços.In Event Viewer, expand Applications and Services Logs.

  3. Localize a listagem de MyNewLog (ou MyLogFile1, se você seguiu o procedimento para adicionar argumentos de linha de comando) e expanda-a.Locate the listing for MyNewLog (or MyLogFile1 if you followed the procedure to add command-line arguments) and expand it. Você deverá ver as entradas para as duas ações (iniciar e parar) executadas pelo serviço.You should see the entries for the two actions (start and stop) that your service performed.

    Use o Visualizador de Eventos para ver as entradas do log de eventos

Limpar recursosClean up resources

Caso não precise mais do aplicativo serviço Windows, remova-o.If you no longer need the Windows service app, you can remove it.

  1. Abra o Prompt de Comando do Desenvolvedor para Visual Studio com credenciais administrativas.Open Developer Command Prompt for Visual Studio with administrative credentials.

  2. Na janela Prompt de Comando do Desenvolvedor para Visual Studio, navegue para a pasta que contém a saída do projeto.In the Developer Command Prompt for Visual Studio window, navigate to the folder that contains your project's output.

  3. Insira o seguinte comando:Enter the following command:

    installutil.exe /u MyNewService.exe
    

    Se o serviço for desinstalado com êxito, o comando relatará que o serviço foi removido com sucesso.If the service uninstalls successfully, the command reports that your service was successfully removed. Para obter mais informações, confira Como: Instalar e desinstalar serviços.For more information, see How to: Install and uninstall services.

Próximas etapasNext steps

Agora que você criou o serviço, você poderá:Now that you've created the service, you can:

  • Criar um programa de instalação autônoma para que outros possam usá-lo para instalar o serviço Windows.Create a standalone setup program for others to use to install your Windows service. Usar o Conjunto de ferramentas do WiX para criar um instalador para um serviço Windows.Use the WiX Toolset to create an installer for a Windows service. Para ver outras ideias, confira Create an installer package (Criar um pacote do instalador).For other ideas, see Create an installer package.

  • Explorar o componente ServiceController, que permite enviar comandos ao serviço instalado.Explore the ServiceController component, which enables you to send commands to the service you've installed.

  • 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.Instead of creating the event log when the application runs, use an installer to create an event log when you install the application. O log de eventos é excluído pelo instalador quando você desinstala o aplicativo.The event log is deleted by the installer when you uninstall the application. Para obter mais informações, consulte EventLogInstaller.For more information, see EventLogInstaller.

Consulte tambémSee also