Esercitazione: Creare un'app di servizio di WindowsTutorial: Create a Windows service app

Questo articolo illustra come creare in Visual Studio un'app di servizio di Windows che scrive messaggi in un log eventi.This article demonstrates how to create a Windows service app in Visual Studio that writes messages to an event log.

Creare un servizioCreate a service

Le prime operazioni da effettuare sono la creazione del progetto e l'impostazione dei valori necessari per garantire il corretto funzionamento del servizio.To begin, create the project and set the values that are required for the service to function correctly.

  1. Dal menu File di Visual Studio scegliere Nuovo > Progetto (o premere CTRL+MAIUSC+N) per aprire la finestra Nuovo progetto.From the Visual Studio File menu, select New > Project (or press Ctrl+Shift+N) to open the New Project window.

  2. Cercare e selezionare il modello di progetto Servizio di Windows (.NET Framework) .Navigate to and select the Windows Service (.NET Framework) project template. Per trovarlo, espandere Installati e Visual C# o Visual Basic e quindi selezionare Windows Desktop.To find it, expand Installed and Visual C# or Visual Basic, then select Windows Desktop. In alternativa, immettere Servizio di Windows nella casella di ricerca in alto a destra e premere Invio.Or, enter Windows Service in the search box on the upper right and press Enter.

    Modello Servizio Windows nella finestra di dialogo Nuovo progetto di Visual Studio

    Nota

    Se il modello Servizio di Windows non è visualizzato, può essere necessario installare il carico di lavoro Sviluppo per desktop .NET:If you don't see the Windows Service template, you may need to install the .NET desktop development workload:

    Nella finestra di dialogo Nuovo progetto selezionare Apri il programma di installazione di Visual Studio in basso a sinistra.In the New Project dialog, select Open Visual Studio Installer on the lower left. Selezionare il carico di lavoro Sviluppo per desktop .NET e quindi selezionare Modifica.Select the .NET desktop development workload, and then select Modify.

  3. Per Nome immettere MyNewService e quindi selezionare OK.For Name, enter MyNewService, and then select OK.

    Verrà visualizzata la scheda Progettazione (Service1.cs [Progettazione] oppure Service1.vb [Progettazione] ).The Design tab appears (Service1.cs [Design] or Service1.vb [Design]).

    Il modello di progetto include una classe di componente denominata Service1 che eredita dalla classe System.ServiceProcess.ServiceBase.The project template includes a component class named Service1 that inherits from System.ServiceProcess.ServiceBase. Include gran parte del codice del servizio di base, ad esempio il codice per avviare il servizio.It includes much of the basic service code, such as the code to start the service.

Rinominare il servizioRename the service

Rinominare il servizio da Service1 a MyNewService.Rename the service from Service1 to MyNewService.

  1. In Esplora soluzioni selezionare Service1.cs o Service1.vb e quindi scegliere Rinomina dal menu di scelta rapida.In Solution Explorer, select Service1.cs, or Service1.vb, and choose Rename from the shortcut menu. Rinominare il file in MyNewService.cs o in MyNewService.vb e quindi premere InvioRename the file to MyNewService.cs, or MyNewService.vb, and then press Enter

    Una finestra popup chiederà se si vogliono rinominare tutti i riferimenti all'elemento di codice Service1.A pop-up window appears asking whether you would like to rename all references to the code element Service1.

  2. Nella finestra popup selezionare .In the pop-up window, select Yes.

    Domanda sulla ridenominazioneRename prompt

  3. Nella scheda Progettazione selezionare Proprietà dal menu di scelta rapida.In the Design tab, select Properties from the shortcut menu. Nella finestra Proprietà cambiare il valore di ServiceName in MyNewService.From the Properties window, change the ServiceName value to MyNewService.

    Proprietà del servizioService properties

  4. Selezionare Salva tutto dal menu File.Select Save All from the File menu.

Aggiungere funzionalità al servizioAdd features to the service

In questa sezione verrà aggiunto un log eventi personalizzato al servizio Windows.In this section, you add a custom event log to the Windows service. Il componente EventLog è un esempio del tipo di componente che è possibile aggiungere a un servizio di Windows.The EventLog component is an example of the type of component you can add to a Windows service.

Aggiungere la funzionalità del log eventi personalizzatoAdd custom event log functionality

  1. Dal menu di scelta rapida per MyNewService.cs o MyNewService.vb in Esplora soluzioni scegliere Visualizza finestra di progettazione.In Solution Explorer, from the shortcut menu for MyNewService.cs, or MyNewService.vb, choose View Designer.

  2. Nella Casella degli strumenti espandere Componenti e quindi trascinare il componente EventLog nella scheda Service1.cs [Progettazione] o Service1.vb [Progettazione] .In Toolbox, expand Components, and then drag the EventLog component to the Service1.cs [Design], or Service1.vb [Design] tab.

  3. Dal menu di scelta rapida per MyNewService.cs o MyNewService.vb in Esplora soluzioni scegliere Visualizza codice.In Solution Explorer, from the shortcut menu for MyNewService.cs, or MyNewService.vb, choose View Code.

  4. Definire un log eventi personalizzato.Define a custom event log. Per C#, modificare il costruttore MyNewService() esistente. Per Visual Basic, aggiungere il costruttore 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. Aggiungere un'istruzione using a MyNewService.cs (se non esiste già) o un'istruzione Imports a MyNewService.vb per lo spazio dei nomi 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. Selezionare Salva tutto dal menu File.Select Save All from the File menu.

Definire quello che accade quando il servizio viene avviatoDefine what occurs when the service starts

Nell'editor di codice per MyNewService.cs o MyNewService.vb individuare il metodo OnStart. Visual Studio ha creato automaticamente una definizione di metodo vuota quando è stato creato il progetto.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. Aggiungere codice che scriva una voce nel log eventi all'avvio del servizio: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

PollingPolling

Poiché le applicazioni di servizio sono progettate per un'esecuzione di lunga durata, generalmente eseguono operazioni di polling o di monitoraggio del sistema, che vengono configurate nel metodo 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. Il metodo OnStart deve rispondere al sistema operativo dopo l'avvio del servizio, perché il sistema non rimanga bloccato.The OnStart method must return to the operating system after the service's operation has begun so that the system isn't blocked.

Per impostare un semplice meccanismo di polling, usare il componente System.Timers.Timer.To set up a simple polling mechanism, use the System.Timers.Timer component. Il timer genera un evento Elapsed a intervalli regolari. In corrispondenza di questo evento il servizio può eseguire il monitoraggio.The timer raises an Elapsed event at regular intervals, at which time your service can do its monitoring. Per usare il componente Timer eseguire le operazioni seguenti:You use the Timer component as follows:

  • Impostare le proprietà del componente Timer nel metodo MyNewService.OnStart.Set the properties of the Timer component in the MyNewService.OnStart method.
  • Avviare il timer tramite una chiamata al metodo Start.Start the timer by calling the Start method.
Configurare il meccanismo di polling.Set up the polling mechanism.
  1. Aggiungere il codice seguente nell'evento MyNewService.OnStart per configurare il meccanismo di polling: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. Aggiungere un'istruzione using a MyNewService.cs o un'istruzione Imports a MyNewService.vb per lo spazio dei nomi 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. Nella classe MyNewService aggiungere il metodo OnTimer per gestire l'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. Nella classe MyNewService aggiungere una variabile membro.In the MyNewService class, add a member variable. Questa contiene l'identificatore dell'evento successivo da scrivere nel log eventi:It contains the identifier of the next event to write into the event log:

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

Invece di eseguire tutto il lavoro nel thread principale, è possibile eseguire le attività tramite thread di lavoro in background.Instead of running all your work on the main thread, you can run tasks by using background worker threads. Per altre informazioni, vedere System.ComponentModel.BackgroundWorker.For more information, see System.ComponentModel.BackgroundWorker.

Definire quello che accade quando il servizio viene arrestatoDefine what occurs when the service is stopped

Inserire nel metodo OnStop una riga di codice che aggiunga una voce nel log eventi all'arresto del servizio: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

Definire altre azioni del servizioDefine other actions for the service

È possibile eseguire l'override dei metodi OnPause, OnContinue e OnShutdown per definire ulteriori operazioni di elaborazione del componente.You can override the OnPause, OnContinue, and OnShutdown methods to define additional processing for your component.

Il codice seguente illustra come eseguire l'override del metodo OnContinue nella 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

Impostare lo stato del servizioSet service status

I servizi segnalano il proprio stato a Gestione controllo servizi, in modo che gli utenti possano stabilire se un servizio funziona correttamente.Services report their status to the Service Control Manager so that a user can tell whether a service is functioning correctly. Per impostazione predefinita, un servizio che eredita da ServiceBase segnala un set limitato di impostazioni di stato, ovvero 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 l'avvio di un servizio richiede tempo, è utile segnalare lo stato SERVICE_START_PENDING.If a service takes a while to start up, it's useful to report a SERVICE_START_PENDING status.

È possibile implementare le impostazioni di stato SERVICE_START_PENDING e SERVICE_STOP_PENDING aggiungendo codice che chiami la funzione SetServiceStatus di Windows.You can implement the SERVICE_START_PENDING and SERVICE_STOP_PENDING status settings by adding code that calls the Windows SetServiceStatus function.

Implementare lo stato corrispondente al servizio in sospesoImplement service pending status

  1. Aggiungere un'istruzione using a MyNewService.cs o un'istruzione Imports a MyNewService.vb per lo spazio dei nomi 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. Aggiungere il codice seguente in MyNewService.cs o in MyNewService.vb per dichiarare i valori di ServiceState e per aggiungere una struttura per lo stato da usare in una chiamata platform invoke: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
    

    Nota

    Gestione controllo servizi usa i membri dwWaitHint e dwCheckpoint della struttura SERVICE_STATUS per determinare il tempo di attesa per l'avvio o l'arresto di un servizio di Windows.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 l'esecuzione dei metodi OnStart e OnStop è prolungata, il servizio può richiedere più tempo chiamando di nuovo SetServiceStatus con un valore di dwCheckPoint incrementato.If your OnStart and OnStop methods run long, your service can request more time by calling SetServiceStatus again with an incremented dwCheckPoint value.

  3. Nella classe MyNewService dichiarare la funzione SetServiceStatus usando platform invoke: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. Per implementare lo stato SERVICE_START_PENDING, aggiungere il codice seguente all'inizio del metodo 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. Aggiungere codice alla fine del metodo OnStart per impostare lo stato su 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. (Facoltativo) Se OnStop è un metodo a esecuzione prolungata, ripetere questa procedura nel metodo OnStop.(Optional) If OnStop is a long-running method, repeat this procedure in the OnStop method. Implementare lo stato SERVICE_STOP_PENDING e restituire lo stato SERVICE_STOPPED prima che il metodo OnStop esca.Implement the SERVICE_STOP_PENDING status and return the SERVICE_STOPPED status before the OnStop method exits.

    Ad esempio: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)
    

Aggiungere programmi di installazione al servizioAdd installers to the service

Prima di eseguire un servizio di Windows, è necessario installarlo, ovvero registrarlo con Gestione controllo servizi.Before you run a Windows service, you need to install it, which registers it with the Service Control Manager. Per gestire i dettagli della registrazione, aggiungere programmi di installazione al progetto.Add installers to your project to handle the registration details.

  1. Dal menu di scelta rapida per MyNewService.cs o MyNewService.vb in Esplora soluzioni scegliere Visualizza finestra di progettazione.In Solution Explorer, from the shortcut menu for MyNewService.cs, or MyNewService.vb, choose View Designer.

  2. Nella visualizzazione Progettazione selezionare l'area di sfondo e quindi scegliere Aggiungi programma di installazione dal menu di scelta rapida.In the Design view, select the background area, then choose Add Installer from the shortcut menu.

    Per impostazione predefinita, Visual Studio aggiunge al progetto una classe di componenti denominata ProjectInstaller, contenente due programmi di installazione.By default, Visual Studio adds a component class named ProjectInstaller, which contains two installers, to your project. Questi programmi di installazione sono destinati al servizio e al processo associato al servizio stesso.These installers are for your service and for the service's associated process.

  3. Nella visualizzazione Progettazione per ProjectInstaller selezionare serviceInstaller1 per un progetto Visual C# o ServiceInstaller1 per un progetto Visual Basic e quindi scegliere Proprietà dal menu di scelta rapida.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. Nella finestra Proprietà verificare che la proprietà ServiceName sia impostata su MyNewService.In the Properties window, verify the ServiceName property is set to MyNewService.

  5. Aggiungere testo alla proprietà Description, ad esempio A sample service (Servizio di esempio).Add text to the Description property, such as A sample service.

    Questo testo, che viene visualizzato nella colonna Descrizione della finestra Servizi, descrive il servizio all'utente.This text appears in the Description column of the Services window and describes the service to the user.

    Descrizione del servizio nella finestra Servizi. Service description in the Services window.

  6. Aggiungere testo alla proprietà DisplayName,Add text to the DisplayName property. ad esempio, MyNewService Display Name (Nome visualizzato di MyNewService).For example, MyNewService Display Name.

    Questo testo viene visualizzato nella colonna Nome visualizzato della finestra Servizi.This text appears in the Display Name column of the Services window. Questo nome può essere diverso dalla proprietà ServiceName, che corrisponde al nome usato dal sistema, ad esempio il nome usato con il comando net start per avviare il servizio.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. Impostare la proprietà StartType su Automatic dall'elenco a discesa.Set the StartType property to Automatic from the drop-down list.

  8. Al termine, la finestra Proprietà dovrebbe avere l'aspetto della figura seguente:When you're finished, the Properties windows should look like the following figure:

    Proprietà del programma di installazione per un servizio di WindowsInstaller Properties for a Windows service

  9. Nella visualizzazione Progettazione per ProjectInstaller scegliere serviceProcessInstaller1 per un progetto Visual C# o ServiceProcessInstaller1 per un progetto Visual Basic e quindi scegliere Proprietà dal menu di scelta rapida.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. Impostare la proprietà Account su LocalSystem dall'elenco a discesa.Set the Account property to LocalSystem from the drop-down list.

    Questa impostazione consente di installare ed eseguire il servizio tramite l'account di sistema locale.This setting installs the service and runs it by using the local system account.

    Importante

    L'account LocalSystem dispone di ampie autorizzazioni, tra cui la possibilità di scrivere nel log eventi.The LocalSystem account has broad permissions, including the ability to write to the event log. Usare questo account con attenzione, perché potrebbe aumentare il rischio di attacchi da parte di software dannoso.Use this account with caution, because it might increase your risk of attacks from malicious software. Per altre attività, è opportuno usare l'account LocalService che opera come utente senza privilegi nel computer locale e presenta credenziali anonime a tutti i server remoti.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. Questo esempio non riesce se si tenta di usare l'account LocalService perché sono necessarie le autorizzazioni per scrivere nel log eventi.This example fails if you try to use the LocalService account, because it needs permission to write to the event log.

Per altre informazioni sui programmi di installazione, vedere Procedura: Aggiungere programmi di installazione all'applicazione di servizio.For more information about installers, see How to: Add installers to your service application.

(Facoltativo) Impostare i parametri di avvio(Optional) Set startup parameters

Nota

Prima di decidere di aggiungere parametri di avvio, valutare se sia l'approccio migliore per passare informazioni al servizio.Before you decide to add startup parameters, consider whether it's the best way to pass information to your service. Anche se i parametri di avvio sono facili da usare e da analizzare e gli utenti possono facilmente eseguirne l'override, possono essere più difficili da individuare e da usare senza documentazione.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. In genere, se il servizio richiede diversi parametri di avvio, è consigliabile usare il Registro di sistema o un file di configurazione.Generally, if your service requires more than just a few startup parameters, you should use the registry or a configuration file instead.

Un servizio di Windows può accettare argomenti della riga di comando o parametri di avvio.A Windows service can accept command-line arguments, or startup parameters. Quando si aggiunge il codice ai parametri di avvio del processo, gli utenti possono avviare il servizio con parametri di avvio personalizzati nella finestra delle proprietà del servizio.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. Questi parametri di avvio, tuttavia, non vengono mantenuti al successivo avvio del servizio.However, these startup parameters aren't persisted the next time the service starts. Per impostare parametri di avvio in modo permanente, impostarli nel Registro di sistema.To set startup parameters permanently, set them in the registry.

Ogni servizio di Windows ha una voce del Registro di sistema nella sottochiave HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services.Each Windows service has a registry entry under the HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services subkey. Nella sottochiave di ogni servizio usare la sottochiave Parameters per archiviare le informazioni a cui il servizio può accedere.Under each service's subkey, use the Parameters subkey to store information that your service can access. È possibile usare i file di configurazione dell'applicazione per un servizio di Windows in modo analogo a come avviene per gli altri tipi di programmi.You can use application configuration files for a Windows service the same way you do for other types of programs. Per codice di esempio, vedere ConfigurationManager.AppSettings.For sample code, see ConfigurationManager.AppSettings.

Per aggiungere parametri di avvioTo add startup parameters

  1. Selezionare Program.cs o MyNewService.Designer.vb e quindi scegliere Visualizza codice dal menu di scelta rapida.Select Program.cs, or MyNewService.Designer.vb, then choose View Code from the shortcut menu. Nel metodo Main modificare il codice aggiungendo un parametro di input e passare quest'ultimo al costruttore del servizio: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. In MyNewService.cs o MyNewService.vb modificare il costruttore MyNewService in modo che elabori il parametro di input come segue: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
    

    Questo codice imposta l'origine e il nome del log dell'evento in base ai parametri di avvio specificati dall'utente.This code sets the event source and log name according to the startup parameters that the user supplies. Se non vengono specificati argomenti, usa i valori predefiniti.If no arguments are supplied, it uses default values.

  3. Per specificare gli argomenti della riga di comando, aggiungere il codice seguente alla classe ProjectInstaller in ProjectInstaller.cs o 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
    

    In genere, questo valore contiene il percorso completo del file eseguibile per il servizio di Windows.Typically, this value contains the full path to the executable for the Windows service. Perché il servizio venga avviato correttamente, è necessario usare le virgolette per il percorso e per ogni singolo parametro.For the service to start up correctly, the user must supply quotation marks for the path and each individual parameter. È possibile cambiare i parametri nella voce del Registro di sistema ImagePath per cambiare i parametri di avvio del servizio di Windows.A user can change the parameters in the ImagePath registry entry to change the startup parameters for the Windows service. Una soluzione migliore, tuttavia, consiste nel cambiare il valore a livello di codice e nell'esporre la funzionalità in un modo semplice da usare, ad esempio tramite un'utilità di gestione o di configurazione.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.

Compilare il servizioBuild the service

  1. In Esplora soluzioni scegliere Proprietà dal menu di scelta rapida del progetto MyNewService.In Solution Explorer, choose Properties from the shortcut menu for the MyNewService project.

    Verranno visualizzate le pagine delle proprietà per il progetto.The property pages for your project appear.

  2. Nell'elenco Oggetto di avvio della scheda Applicazione scegliere MyNewService.Program o Sub Main per i progetti Visual Basic.On the Application tab, in the Startup object list, choose MyNewService.Program, or Sub Main for Visual Basic projects.

  3. Per compilare il progetto, in Esplora soluzioni scegliere Compila dal menu di scelta rapida del progetto o premere CTRL+MAIUSC+B.To build the project, in Solution Explorer, choose Build from the shortcut menu for your project (or press Ctrl+Shift+B).

Installare il servizioInstall the service

Una volta compilato il servizio Windows, è possibile installarlo.Now that you've built the Windows service, you can install it. Per installare un servizio di Windows, è necessario avere credenziali di amministratore per il computer in cui il servizio è installato.To install a Windows service, you must have administrator credentials on the computer where it's installed.

  1. Aprire il Prompt dei comandi per gli sviluppatori per Visual Studio con credenziali amministrative.Open Developer Command Prompt for Visual Studio with administrative credentials. Dal menu Start di Windows selezionare Prompt dei comandi per gli sviluppatori per VS 2017 nella cartella di Visual Studio e quindi selezionare Altro > Esegui come amministratore dal menu di scelta rapida.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. Nella finestra Prompt dei comandi per gli sviluppatori per Visual Studio passare alla cartella contenente l'output del progetto, per impostazione predefinita la sottodirectory \bin\Debug del progetto.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. Immettere il comando seguente:Enter the following command:

    installutil MyNewService.exe
    

    Se il servizio viene installato correttamente, il comando segnala l'esito positivo.If the service installs successfully, the command reports success.

    Se il sistema non riesce a trovare installutil.exe, assicurarsi che sia presente nel computer in uso.If the system can't find installutil.exe, make sure that it exists on your computer. Questo strumento viene installato con .NET Framework nella cartella %windir%\Microsoft.NET\Framework[64]\<versione framework> .This tool is installed with the .NET Framework to the folder %windir%\Microsoft.NET\Framework[64]\<framework version>. Il percorso predefinito per la versione a 64 bit, ad esempio, è %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 il processo installutil.exe ha esito negativo, controllare il log di installazione per determinarne il motivo.If the installutil.exe process fails, check the install log to find out why. Per impostazione predefinita, il log è nella stessa cartella del file eseguibile del servizio.By default, the log is in the same folder as the service executable. L'installazione può non riuscire se:The installation can fail if:

    • La classe RunInstallerAttribute non è presente nella classe ProjectInstaller.The RunInstallerAttribute class isn't present on the ProjectInstaller class.
    • L'attributo non è impostato su true.The attribute isn't set to true.
    • La classe ProjectInstaller non è definita come public.The ProjectInstaller class isn't defined as public.

Per altre informazioni, vedere Procedura: Installare e disinstallare servizi.For more information, see How to: Install and uninstall services.

Avviare ed eseguire il servizioStart and run the service

  1. In Windows aprire l'app desktop Servizi.In Windows, open the Services desktop app. Premere Windows+R per aprire la casella Esegui, immettere services.msc e quindi premere INVIO o selezionare OK.Press Windows+R to open the Run box, enter services.msc, and then press Enter or select OK.

    Il servizio verrà elencato in Servizi, in ordine alfabetico in base al nome visualizzato impostato.You should see your service listed in Services, displayed alphabetically by the display name that you set for it.

    MyNewService nella finestra Servizi.

  2. Per avviare il servizio, scegliere Avvia dal menu di scelta rapida del servizio.To start the service, choose Start from the service's shortcut menu.

  3. Per arrestare il servizio, scegliere Arresta dal menu di scelta rapida del servizio.To stop the service, choose Stop from the service's shortcut menu.

  4. (Facoltativo) Dalla riga di comando usare i comandi net start <nome servizio> e net stop <nome servizio> per avviare e arrestare il servizio.(Optional) From the command line, use the commands net start <service name> and net stop <service name> to start and stop your service.

Verificare l'output del log eventi del servizioVerify the event log output of your service

  1. In Windows aprire l'app desktop Visualizzatore eventi.In Windows, open the Event Viewer desktop app. Immettere Visualizzatore eventi nella barra di ricerca di Windows e quindi selezionare Visualizzatore eventi dai risultati della ricerca.Enter Event Viewer in the Windows search bar, and then select Event Viewer from the search results.

    Suggerimento

    In Visual Studio è possibile accedere ai log eventi aprendo Esplora server dal menu Visualizza, o premendo CTRL+ALT+S, ed espandendo il nodo Log eventi per il computer locale.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. Nel Visualizzatore eventi espandere Registri applicazioni e servizi.In Event Viewer, expand Applications and Services Logs.

  3. Individuare l'elenco per MyNewLog (o MyLogFile1, se è stata seguita la procedura per aggiungere argomenti della riga di comando) ed espanderlo.Locate the listing for MyNewLog (or MyLogFile1 if you followed the procedure to add command-line arguments) and expand it. Verranno visualizzate le voci per le due azioni (avvio e arresto) eseguite dal servizio.You should see the entries for the two actions (start and stop) that your service performed.

    Usare il Visualizzatore eventi per visualizzare le voci del log eventi

Pulire le risorseClean up resources

Se l'app del servizio di Windows non è più necessaria, è possibile rimuoverla.If you no longer need the Windows service app, you can remove it.

  1. Aprire il Prompt dei comandi per gli sviluppatori per Visual Studio con credenziali amministrative.Open Developer Command Prompt for Visual Studio with administrative credentials.

  2. Nella finestra Prompt dei comandi per gli sviluppatori per Visual Studio passare alla cartella contenente l'output del progetto.In the Developer Command Prompt for Visual Studio window, navigate to the folder that contains your project's output.

  3. Immettere il comando seguente:Enter the following command:

    installutil.exe /u MyNewService.exe
    

    Se il servizio viene disinstallato correttamente, il comando segnala che il servizio è stato rimosso correttamente.If the service uninstalls successfully, the command reports that your service was successfully removed. Per altre informazioni, vedere Procedura: Installare e disinstallare servizi.For more information, see How to: Install and uninstall services.

Passaggi successiviNext steps

Dopo aver creato il servizio, è possibile:Now that you've created the service, you can:

  • Creare un programma di installazione autonomo che gli altri utenti possono usare per installare il servizio di Windows.Create a standalone setup program for others to use to install your Windows service. Usare il set di strumenti WiX per creare un programma di installazione per un servizio di Windows.Use the WiX Toolset to create an installer for a Windows service. Per altre idee, vedere Creare un pacchetto di installazione.For other ideas, see Create an installer package.

  • Esaminare il componente ServiceController, che consente di inviare comandi al servizio installato.Explore the ServiceController component, which enables you to send commands to the service you've installed.

  • Anziché creare il log eventi durante l'esecuzione dell'applicazione, crearlo durante l'installazione dell'applicazione stessa tramite il programma di installazione.Instead of creating the event log when the application runs, use an installer to create an event log when you install the application. Il log eventi viene eliminato dal programma di installazione quando si disinstalla l'applicazione.The event log is deleted by the installer when you uninstall the application. Per altre informazioni, vedere EventLogInstaller.For more information, see EventLogInstaller.

Vedere ancheSee also