Didacticiel : Créer une application de service Windows

Article
05/10/2023

Avertissement

Cette documentation ne concerne pas la dernière version du service Windows. Pour obtenir le contenu le plus récent sur les services Windows utilisant BackgroundService et le modèle de service Worker, consultez :

Cet article explique comment créer, dans Visual Studio, une application de service Windows qui écrit des messages dans un journal des événements.

Créer un service

Pour commencer, créez le projet et définissez les valeurs nécessaires au fonctionnement correct du service.

Dans le menu Fichier de Visual Studio, sélectionnez Nouveau>Projet (ou appuyez sur Ctrl+Maj+N) pour ouvrir la fenêtre Nouveau projet.
Recherchez le modèle de projet Service Windows (.NET Framework) et sélectionnez-le.

Notes

Si vous ne voyez pas le modèle Service Windows, vous devrez peut-être installer la charge de travail Développement .NET Desktop à l’aide de Visual Studio Installer.
Dans Nom, entrez MyNewService, puis sélectionnez OK.

L’onglet Conception apparaît (Service1.cs [Conception] ou Service1.vb [Conception]).

Le modèle de projet inclut une classe Component appelée Service1 qui hérite de System.ServiceProcess.ServiceBase. Elle contient une grande partie du code de service de base, comme le code pour démarrer le service.

Renommer le service

Renommez le service Service1 en MyNewService.

Dans l’Explorateur de solutions, sélectionnez Service1.cs ou Service1.vb, puis choisissez Renommer dans le menu contextuel. Renommez le fichier MyNewService.cs ou MyNewService.vb, puis appuyez sur Entrée.

Une fenêtre contextuelle vous invite à indiquer si vous voulez renommer toutes les références à l’élément de code Service1.
Dans cette fenêtre, sélectionnez Oui.
Sous l’onglet Conception, sélectionnez Propriétés dans le menu contextuel. Dans la fenêtre Propriétés, remplacez la valeur ServiceName par MyNewService.
Sélectionnez Enregistrer tout dans le menu Fichier.

Ajouter des fonctionnalités au service

Dans cette section, vous ajoutez un journal des événements personnalisé au service Windows. Le composant EventLog est un exemple du type de composant que vous pouvez ajouter à un service Windows.

Ajouter une fonctionnalité de journal des événements personnalisé

Dans l’Explorateur de solutions, dans le menu contextuel de MyNewService.cs ou MyNewService.vb, choisissez Concepteur de vues.
Dans Boîte à outils, développez Composants, puis faites glisser le composant EventLog vers l’onglet Service1.cs [Conception] ou Service1.vb [Conception].
Dans l’Explorateur de solutions, dans le menu contextuel de MyNewService.cs ou MyNewService.vb, choisissez Afficher le code.

Définissez un journal des événements personnalisé.

Pour C#, modifiez le constructeur MyNewService() existant, comme illustré dans l’extrait de code suivant. Pour Visual Basic, ajoutez le constructeur New(), comme illustré dans l’extrait de code suivant.

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

Ajoutez une instruction using à MyNewService.cs (si elle n’existe pas déjà) ou une instruction Imports à MyNewService.vb, pour l’espace de noms System.Diagnostics :
```
using System.Diagnostics;
```
```
Imports System.Diagnostics
```
Sélectionnez Enregistrer tout dans le menu Fichier.

Définir les actions à effectuer lors du démarrage du service

Dans l’éditeur de code pour MyNewService.cs ou MyNewService.vb, recherchez la méthode OnStart. Visual Studio a automatiquement créé une définition de méthode vide quand vous avez créé le projet. Ajoutez du code qui écrit une entrée dans le journal des événements lorsque le service démarre :

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

Interrogation

Étant donné qu’une application de service est conçue pour être durable, elle interroge ou supervise généralement le système, que vous configurez dans la méthode OnStart. La méthode OnStart doit retourner au système d’exploitation une fois que le service a commencé à fonctionner pour que le système ne soit pas bloqué.

Pour configurer un mécanisme d’interrogation simple, utilisez le composant System.Timers.Timer. Le minuteur déclenche un événement Elapsed à intervalles réguliers, moment auquel votre service peut effectuer sa supervision. Vous utilisez le composant Timer comme suit :

Définissez les propriétés du composant Timer dans la méthode MyNewService.OnStart.
Démarrez le minuteur en appelant la méthode Start.

Configurer le mécanisme d’interrogation

Ajoutez une instruction using à MyNewService.cs ou une instruction Imports à MyNewService.vb pour l’espace de noms System.Timers :
```
using System.Timers;
```
```
Imports System.Timers
```

Ajoutez le code suivant dans l’événement MyNewService.OnStart pour configurer le mécanisme d’interrogation :

// 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()

Dans la classe MyNewService, ajoutez une variable membre. Celle-ci contient l’identificateur de l’événement suivant à écrire dans le journal des événements :
```
private int eventId = 1;
```
```
Private eventId As Integer = 1
```

Dans la classe MyNewService, ajoutez la méthode OnTimer pour gérer l’événement 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

Au lieu d’exécuter tout votre travail sur le thread principal, vous pouvez exécuter des tâches à l’aide de threads de travail en arrière-plan. Pour plus d’informations, consultez System.ComponentModel.BackgroundWorker.

Définir les actions à effectuer lors de l'arrêt du service

Insérez une ligne de code dans la méthode OnStop qui ajoute une entrée dans le journal des événements lorsque le service est arrêté :

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

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

Définir d'autres actions du service

Vous pouvez substituer les méthodes OnPause, OnContinue et OnShutdown afin de définir d'autres types de traitement pour votre composant.

Le code suivant montre comment substituer la méthode OnContinue dans la classe MyNewService :

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

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

Définir l’état du service

Les services indiquent leur état au Gestionnaire de contrôle des services. Les utilisateurs peuvent ainsi déterminer si un service fonctionne correctement. Par défaut, un service qui hérite de ServiceBase signale un ensemble limité de paramètres d’état, qui incluent SERVICE_STOPPED, SERVICE_PAUSED et SERVICE_RUNNING. Si un service prend du temps à démarrer, il s’avère utile de signaler un état SERVICE_START_PENDING.

Vous pouvez implémenter les paramètres d’état SERVICE_START_PENDING et SERVICE_STOP_PENDING en ajoutant du code qui appelle la fonction SetServiceStatus Windows.

Implémenter l’état de service en attente

Ajoutez une instruction using à MyNewService.cs ou une instruction Imports à MyNewService.vb pour l’espace de noms System.Runtime.InteropServices :
```
using System.Runtime.InteropServices;
```
```
Imports System.Runtime.InteropServices
```

Ajoutez le code suivant à MyNewService.cs ou MyNewService.vb pour déclarer les valeurs ServiceState et ajouter une structure pour l’état. Vous utiliserez cette structure dans un appel de code non managé :

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

Notes

La boîte de dialogue Gestionnaire de contrôle des services utilise les membres dwWaitHint et dwCheckpoint de la structure SERVICE_STATUS pour déterminer le délai d’attente avant le démarrage ou l’arrêt d’un service Windows. Si l’exécution de vos méthodes OnStart et OnStop est longue, votre service peut demander plus de temps en appelant à nouveau SetServiceStatus avec une valeur dwCheckPoint incrémentée.

Dans la classe MyNewService, déclarez la fonction SetServiceStatus à l’aide d’un appel de code non managé :

[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

Pour implémenter l’état SERVICE_START_PENDING, ajoutez le code suivant au début de la méthode 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)

Ajoutez du code à la fin de la méthode OnStart pour affecter à l’état la valeur 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)

(Facultatif) Si OnStop est une méthode durable, répétez cette procédure dans la méthode OnStop. Implémentez l’état SERVICE_STOP_PENDING et retournez l’état SERVICE_STOPPED avant la fin de la méthode OnStop.

Par exemple :

// 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)

Ajouter des programmes d'installation pour le service

Avant d’exécuter un service Windows, vous devez l’installer, ce qui ’inscrit auprès du Gestionnaire de contrôle des services. Ajoutez à votre projet des programmes d’installation pour gérer les détails de l’inscription.

Dans l’Explorateur de solutions, dans le menu contextuel de MyNewService.cs ou MyNewService.vb, choisissez Concepteur de vues.
En mode Conception, sélectionnez la zone d’arrière-plan, puis choisissez Ajouter le programme d’installation dans le menu contextuel.

Par défaut, Visual Studio ajoute une classe Component nommée ProjectInstaller, qui contient deux programmes d’installation, à votre projet. Ces programmes d’installation sont destinés à votre service et au processus associé du service.
En mode Conception pour ProjectInstaller, sélectionnez serviceInstaller1 pour un projet Visual C# ou ServiceInstaller1 pour un projet Visual Basic, puis choisissez Propriétés dans le menu contextuel.
Dans la fenêtre Propriétés, vérifiez que la propriété ServiceName a la valeur MyNewService.
Ajoutez du texte à la propriété Description, comme Un exemple de service.

Ce texte apparaît dans la colonne Description de la fenêtre Services et explique le service à l’utilisateur.
Ajoutez du texte à la propriété DisplayName. Par exemple, Nom complet de MyNewService.

Ce texte apparaît dans la colonne Nom complet de la fenêtre Services. Ce nom peut être différent de la propriété ServiceName, qui est le nom utilisé par le système (par exemple, le nom que vous utilisez pour la commande net start pour démarrer votre service).
Affectez à la propriété StartType la valeur Automatic à partir de la liste déroulante.
Quand vous avez terminé, la fenêtre Propriétés doit ressembler à la figure suivante :
En mode Conception pour ProjectInstaller, choisissez serviceProcessInstaller1 pour un projet Visual C# ou ServiceProcessInstaller1 pour un projet Visual Basic, puis choisissez Propriétés dans le menu contextuel. Affectez à la propriété Account la valeur LocalSystem à partir de la liste déroulante.

Ce paramètre installe le service et l’exécute en utilisant le compte système local.

Important

Le compte LocalSystem dispose d'autorisations générales, y compris la possibilité d'écrire dans le journal des événements. Utilisez ce compte avec précaution car il peut augmenter le risque d'attaques par des logiciels malveillants. Pour les autres tâches, utilisez le compte LocalService , qui se comporte comme un utilisateur non privilégié de l'ordinateur local et présente des informations d'identification anonymes à tout serveur distant. Cet exemple échoue si vous essayez d'utiliser le compte LocalService , car il doit disposer d'une autorisation pour écrire dans le journal des événements.

Pour plus d’informations sur les programmes d’installation, consultez Guide pratique pour ajouter des programmes d’installation à votre application de service.

(Facultatif) Définition de paramètres de démarrage

Notes

Avant de décider d’ajouter des paramètres de démarrage, déterminez si c’est le meilleur moyen de passer des informations à votre service. Bien qu’ils soient faciles à utiliser et à analyser et qu’un utilisateur puisse facilement les substituer, ils peuvent être plus difficiles à découvrir et utiliser pour un utilisateur sans documentation. En général, si votre service nécessite seulement quelques paramètres de démarrage, il est préférable d’utiliser plutôt le Registre ou un fichier de configuration.

Un service Windows peut accepter des arguments de ligne de commande ou des paramètres de démarrage. Quand vous ajoutez du code pour traiter des paramètres de démarrage, un utilisateur peut démarrer votre service avec ses propres paramètres de démarrage personnalisés dans la fenêtre des propriétés du service. Toutefois, ces paramètres de démarrage ne sont pas persistants lors du prochain démarrage du service. Pour définir des paramètres de démarrage de façon définitive, faites-le dans le Registre.

Chaque service Windows a une entrée de Registre sous la sous-clé HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services. Sous la sous-clé de chaque service, utilisez la sous-clé Parameters pour stocker les informations auxquelles votre service peut accéder. Vous pouvez utiliser des fichiers de configuration d'application pour un service Windows de la même façon que vous le faites pour les autres types de programmes. Pour l’exemple de code, consultez ConfigurationManager.AppSettings.

Pour ajouter des paramètres de démarrage

Sélectionnez Program.cs ou MyNewService.Designer.vb, puis choisissez Afficher le code dans le menu contextuel. Dans la méthode Main, modifiez le code pour ajouter un paramètre d’entrée et le passer au constructeur du service :

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

Dans MyNewService.cs ou MyNewService.vb, modifiez le constructeur MyNewService pour traiter le paramètre d’entrée comme suit :

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

Ce code définit la source de l’événement et le nom du journal en fonction des paramètres de démarrage fournis par l’utilisateur. Si aucun argument n’est fourni, les valeurs par défaut sont utilisées.

Pour spécifier les arguments de ligne de commande, ajoutez le code suivant à la classe ProjectInstaller dans 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
```
En règle générale, cette valeur contient le chemin complet de l’exécutable du service Windows. Pour que le service démarre correctement, l’utilisateur doit fournir des guillemets pour le chemin et chaque paramètre individuel. Un utilisateur peut changer les paramètres dans l’entrée de Registre ImagePath pour changer les paramètres de démarrage du service Windows. Toutefois, un meilleur moyen consiste à changer la valeur programmatiquement et à exposer les fonctionnalités de manière conviviale, par exemple à l’aide d’un utilitaire de gestion ou de configuration.

Générer le service

Dans l’Explorateur de solutions, choisissez Propriétés dans le menu contextuel du projet MyNewService.

Les pages de propriétés de votre projet s'affichent.
Sous l’onglet Application, dans la liste Objet de démarrage, choisissez MyNewService.Program ou Sub Main pour les projets Visual Basic.
Pour générer le projet, dans l’Explorateur de solutions, choisissez Build dans le menu contextuel de votre projet (ou appuyez sur Ctrl+Maj+B).

Installer le service

Maintenant que vous avez généré le service Windows, vous pouvez l'installer. Pour installer un service Windows, vous devez disposer d’informations d’identification d’administrateur sur l’ordinateur sur lequel il est installé.

Ouvrez Invite de commandes développeur pour Visual Studio avec des informations d'identification administratives.
Dans Invite de commandes développeur pour Visual Studio, accédez au dossier qui contient la sortie de votre projet (par défaut, le sous-répertoire \bin\Debug de votre projet).
Entrez la commande suivante :
```
installutil MyNewService.exe
```
Si le service s’installe correctement, la commande signale une réussite.

Si le système ne trouve pas installutil.exe, vérifiez qu’il existe sur votre ordinateur. Cet outil est installé avec le .NET Framework dans le dossier %windir%\Microsoft.NET\Framework[64]\<version du framework>. Par exemple, le chemin par défaut pour la version 64 bits est %windir%\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe.

Si le processus installutil.exe échoue, examinez le journal d’installation pour en connaître la raison. Par défaut, le journal se trouve dans le même dossier que l’exécutable du service. L’installation peut échouer si :
- La classe RunInstallerAttribute n’est pas présente sur la classe ProjectInstaller.
- L’attribut n’a pas la valeur true.
- La classe ProjectInstaller n’est pas définie en tant que public.

Pour plus d’informations, consultez Guide pratique pour installer et désinstaller des services.

Démarrer et exécuter le service

Dans Windows, ouvrez l’application de bureau Services. Appuyez sur Windows+R pour ouvrir la zone Exécuter, entrez services.msc, puis appuyez sur Entrée ou sélectionnez OK.

Votre service doit être répertorié dans Services, affiché par ordre alphabétique du nom d’affichage que vous lui avez donné.
Pour démarrer le service, choisissez Démarrer dans le menu contextuel du service.
Pour arrêter le service, choisissez Arrêter dans le menu contextuel du service.
(Facultatif) À partir de la ligne de commande, utilisez les commandes net start <nom du service> et net stop <nom du service> pour démarrer et arrêter votre service.

Vérifier la sortie du journal des événements de votre service

Dans Windows, ouvrez l’application de bureau Observateur d’événements. Entrez Observateur d’événements dans la barre de recherche Windows, puis sélectionnez Observateur d’événements dans les résultats de la recherche.

Conseil

Dans Visual Studio, vous pouvez accéder aux journaux des événements en ouvrant l’Explorateur de serveurs à partir du menu Affichage (ou appuyez sur Ctrl+Alt+S), puis en développant le nœud Journaux des événements pour l’ordinateur local.
Dans l’Observateur d’événements, développez Journaux des applications et services.
Recherchez le nom MyNewLog (ou MyLogFile1, si vous avez utilisé la procédure pour ajouter des arguments de ligne de commande) dans la liste, puis développez-le. Vous devez voir les entrées relatives aux deux actions (démarrage et arrêt) que votre service a effectuées.

Nettoyer les ressources

Si vous n’avez plus besoin de l’application de service Windows, vous pouvez la supprimer.

Ouvrez Invite de commandes développeur pour Visual Studio avec des informations d'identification administratives.
Dans la fenêtre Invite de commandes développeur pour Visual Studio, accédez au dossier qui contient la sortie de votre projet.
Entrez la commande suivante :
```
installutil.exe /u MyNewService.exe
```
Si le service se désinstalle correctement, la commande signale qu’il a été correctement supprimé. Pour plus d’informations, consultez Guide pratique pour installer et désinstaller des services.

Étapes suivantes

Maintenant que vous avez créé le service, vous pouvez :

Créer un programme d’installation autonome utilisable par d’autres personnes pour installer votre service Windows. Utiliser WiX Toolset pour créer un programme d’installation pour un service Windows. Pour d’autres idées, consultez Créer un package de programme d’installation.
Explorer le composant ServiceController, qui vous permet d’envoyer des commandes au service que vous avez installé.
Au lieu de créer le journal des événements quand l’application s’exécute, utilisez un programme d’installation pour créer un journal des événements quand vous installez l’application. Le journal des événements est supprimé par le programme d’installation quand vous désinstallez l’application. Pour plus d’informations, consultez EventLogInstaller.

Partager via