Tutoriel : Créer une application de service Windows

Cet article montre comment créer une application de service Windows .NET Framework dans Visual Studio. Le service écrit simplement des messages dans un journal des événements.

Créer un service

Pour commencer, créez le projet et définissez les valeurs requises pour que le service fonctionne correctement.

1. Dans le menu Fichier Visual Studio, sélectionnez Nouveau>projet (ou appuyez sur Ctrl+Maj+N) pour ouvrir la fenêtre Nouveau projet .

2. Recherchez et sélectionnez le modèle de projet Windows Service (.NET Framework ).

   Note

   Si vous ne voyez pas le modèle de service Windows , vous devrez peut-être installer la charge de travail de développement de bureau .NET à l’aide de Visual Studio Installer.

3. Pour le nom du projet, entrez MyNewService, puis sélectionnez Créer.

   L’onglet Création s’affiche (Service1.cs [Création] ou Service1.vb [Conception]).

   Le modèle de projet inclut une classe de composant nommée Service1 qui hérite de System.ServiceProcess.ServiceBase. Il inclut une grande partie du code de service de base, tel que le code pour démarrer le service.

Renommer le service

Renommez le service de Service1 en MyNewService.

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

   Une fenêtre contextuelle s’affiche pour vous demander si vous souhaitez renommer toutes les références à l’élément de code Service1.

2. Dans la fenêtre contextuelle, sélectionnez Oui.

   

3. 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 EventLog composant est un exemple du type de composant que vous pouvez ajouter à un service Windows.

Ajouter des fonctionnalités de journal des événements personnalisées

1. Dans la fenêtre Boîte à outils, développez Composants, puis faites glisser le composant EventLog vers le concepteur Service1.cs [Conception] ou Service1.vb [Conception].

   Conseil / Astuce

   Si vous ne voyez pas la fenêtre Boîte à outils, sélectionnez Afficher> laboîte à outils.

2. Dans l’Explorateur de solutions, dans le menu contextuel pour MyNewService.cs ou MyNewService.vb, choisissez Afficher le code.

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

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

   public MyNewService()
   {
       InitializeComponent();
       eventLog1 = new EventLog();
       if (!EventLog.SourceExists("MySource"))
       {
           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
   

4. S’il n’existe pas encore, ajoutez une using directive à MyNewService.cs, ou une Imports instruction à MyNewService.vb, pour l’espace System.Diagnostics de noms :

   using System.Diagnostics;
   

   Imports System.Diagnostics
   

5. Sélectionnez Enregistrer tout dans le menu Fichier .

Définir ce qui se produit au démarrage du service

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

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

Sondages

Étant donné qu'une application de service est conçue pour fonctionner pendant une longue durée, elle sonde ou surveille généralement le système que vous avez configuré dans la méthode OnStart. La OnStart méthode doit revenir au système d’exploitation une fois que l’opération du service a commencé afin que le système ne soit pas bloqué.

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

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

Configurer le mécanisme d’interrogation

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

   using System.Timers;
   

   Imports System.Timers
   

2. 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
   {
       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()
   

3. Dans la MyNewService classe, ajoutez une variable membre. Il contient l’identificateur de l’événement suivant à écrire dans le journal des événements :

   private int eventId = 1;
   

   Private eventId As Integer = 1
   

4. Dans la MyNewService classe, ajoutez la OnTimer méthode 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 ce qui se produit lorsque le service est arrêté

Insérez une ligne de code dans la OnStop méthode qui ajoute une entrée au 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 pour le service

Vous pouvez remplacer les méthodes OnPause, OnContinue et OnShutdown pour définir un traitement supplémentaire pour votre composant.

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

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 signalent leur état au Gestionnaire de contrôle de service afin qu’un utilisateur puisse indiquer si un service fonctionne correctement. Par défaut, un service qui hérite de ServiceBase signale un ensemble limité de paramètres d'état, notamment SERVICE_STOPPED, SERVICE_PAUSED, et SERVICE_RUNNING. Si un service prend un certain temps pour démarrer, il est utile de signaler un SERVICE_START_PENDING état.

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

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

   using System.Runtime.InteropServices;
   

   Imports System.Runtime.InteropServices
   

2. Ajoutez l’énumération et la structure suivantes à MyNewService.cs, ou MyNewService.vb, pour déclarer les ServiceState valeurs et ajouter une structure pour l’état, que vous utiliserez dans un appel d’appel de plateforme :

   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
   

   Note

   Le Service Control Manager utilise les membres dwWaitHint et dwCheckpoint de la structure SERVICE_STATUS pour déterminer le délai d'attente pour qu'un service Windows démarre ou s'arrête. Si vos méthodes OnStart et OnStop s’exécutent longtemps, votre service peut demander plus de temps en appelant à nouveau SetServiceStatus avec une valeur incrémentée dwCheckPoint.

3. Dans la MyNewService classe, déclarez la fonction SetServiceStatus à l’aide de l’appel de plateforme :

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

   // Update the service state to Start Pending.
   ServiceStatus serviceStatus = new ServiceStatus
   {
       dwCurrentState = ServiceState.SERVICE_START_PENDING,
       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. Ajoutez du code à la fin de la OnStart méthode pour définir l’état sur 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. (Facultatif) S’il s’agit OnStop d’une méthode longue, répétez cette procédure dans la OnStop méthode. Implémentez l’état SERVICE_STOP_PENDING et retournez l’état SERVICE_STOPPED avant la sortie de la OnStop méthode.

   Par exemple:

   // Update the service state to Stop Pending.
   ServiceStatus serviceStatus = new ServiceStatus
   {
       dwCurrentState = ServiceState.SERVICE_STOP_PENDING,
       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 installateurs au service

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

1. Dans l’Explorateur de solutions, dans le menu contextuel de MyNewService.cs ou MyNewService.vb, choisissez Concepteur de vues.

2. Dans le mode Création , 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 de composant nommée ProjectInstaller, qui contient deux programmes d’installation, à votre projet. Ces programmes d’installation concernent votre service et le processus associé au service.

3. Dans l’affichage Création de ProjectInstaller, sélectionnez serviceInstaller1 pour un projet C# ou ServiceInstaller1 pour un projet Visual Basic, puis choisissez Propriétés dans le menu contextuel.

4. Dans la fenêtre Propriétés , définissez la ServiceName propriété sur MyNewService.

5. Ajoutez du texte à la propriété Description, par exemple un exemple de service.

   Ce texte apparaît dans la colonne Description de la fenêtre Services et décrit le service à l’utilisateur.

   

6. Ajoutez du texte à la DisplayName propriété. Par exemple, MyNewService Display Name.

   Ce texte apparaît dans la colonne Nom complet de la fenêtre Services . Ce nom peut être différent de la ServiceName propriété, qui est le nom utilisé par le système (par exemple, le nom que vous utilisez pour la net start commande pour démarrer votre service).

7. Définissez la StartType propriété à Automatic partir de la liste déroulante.

8. Lorsque vous avez terminé, les fenêtres Propriétés doivent ressembler à la figure suivante :

   

9. Dans l’affichage Création de ProjectInstaller, choisissez serviceProcessInstaller1 pour un projet C# ou ServiceProcessInstaller1 pour un projet Visual Basic, puis choisissez Propriétés dans le menu contextuel. Définissez la propriété Account sur LocalSystem dans la liste déroulante.

   Ce paramètre installe le service et l’exécute à l’aide du compte système local.

   Important

   Le LocalSystem compte dispose d’autorisations étendues, notamment la possibilité d’écrire dans le journal des événements. Utilisez ce compte avec précaution, car il peut augmenter vos risques d’attaques à partir de logiciels malveillants. Pour d’autres tâches, envisagez d’utiliser le LocalService compte, qui agit en tant qu’utilisateur non privilégié sur l’ordinateur local et présente des informations d’identification anonymes à n’importe quel serveur distant. Toutefois, cet exemple échoue si vous essayez d’utiliser le LocalService compte, car il doit être autorisé à é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éfinir les paramètres de démarrage

Un service Windows peut accepter des arguments de ligne de commande, également appelés paramètres de démarrage. Lorsque vous ajoutez du code pour traiter les 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 conservés la prochaine fois que le service démarre.

Pour définir définitivement les paramètres de démarrage, définissez-les 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 pour d’autres types de programmes. Pour obtenir un exemple de code, consultez ConfigurationManager.AppSettings.

Pour ajouter des paramètres de démarrage

1. Dans MyNewService.cs, ou MyNewService.vb, modifiez le MyNewService constructeur pour accepter et traiter un paramètre d’entrée :

   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;
   }
   

   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 d’événement et le nom du journal en fonction des paramètres de démarrage que l’utilisateur fournit. Si aucun argument n’est fourni, il utilise des valeurs par défaut.

2. Sélectionnez Program.cs ou MyNewService.Designer.vb, puis sélectionnez Afficher le code dans le menu contextuel. Dans la Main méthode, modifiez le code pour ajouter un paramètre d’entrée et passez-le au constructeur de 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
   

3. Pour spécifier les arguments de ligne de commande, ajoutez le code suivant à la ProjectInstaller classe 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 du fichier exécutable pour le service Windows. Pour que le service démarre correctement, l’utilisateur doit fournir des guillemets pour le chemin d’accès et chaque paramètre individuel. Un utilisateur peut modifier les paramètres de l’entrée de Registre ImagePath pour modifier les paramètres de démarrage du service Windows. Toutefois, une meilleure façon est de modifier la valeur par programmation et d’exposer les fonctionnalités d’une manière conviviale, par exemple à l’aide d’un utilitaire de gestion ou de configuration.

Construire le service

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

2. Sous l’onglet Application , dans la liste des objets de démarrage , choisissez MyNewService.Program (ou Sub Main pour les projets Visual Basic).

3. Pour générer le projet, dans l’Explorateur de solutions, choisissez Générer dans le menu contextuel de votre projet (ou appuyez sur Ctrl+Maj+B).

Installer le service

Maintenant que vous avez créé 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é.

1. Ouvrez l’invite de commandes du développeur pour Visual Studio avec des droits administratifs.

2. Dans la fenêtre de commandes développeur pour Visual Studio, naviguez vers le dossier qui contient la sortie de votre projet (par défaut, le sous-répertoire \bin\Debug de votre projet).

3. Entrez la commande suivante :

   installutil MyNewService.exe
   

   Si le service s’installe correctement, la commande signale la réussite.

   Si le système ne trouve pas installutil.exe, assurez-vous qu’il existe sur votre ordinateur. Cet outil est installé avec .NET Framework dans le dossier %windir%\Microsoft.NET\Framework[64]\<framework version>.

   Si le processus installutil.exe échoue, consultez le journal d’installation pour savoir pourquoi. Par défaut, le journal se trouve dans le même dossier que l’exécutable du service. L’installation peut échouer si :

   • La RunInstallerAttribute classe n’est pas présente sur la ProjectInstaller classe.
   • L’attribut n’est pas défini sur true.
   • La ProjectInstaller classe n’est pas définie en tant que public.
   • Vous n’avez pas ouvert le Developer Command Prompt pour VS en tant qu’administrateur.

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

Démarrer et exécuter le service

1. 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.

   Vous devez voir votre service répertorié dans Services, affiché par ordre alphabétique par le nom d’affichage que vous avez défini pour celui-ci.

   

2. Pour démarrer le service, choisissez Démarrer dans le menu contextuel du service.

3. Pour arrêter le service, choisissez Arrêter dans le menu contextuel du service.

4. (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érifiez la sortie du journal des événements de votre service

1. Dans Windows, ouvrez l’application de bureau Observateur d’événements : entrez l’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 / Astuce

   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) et en développant le nœud Journaux des événements pour l’ordinateur local.

2. Dans l’Observateur d’événements, déroulez Journaux des applications et des services.

3. Recherchez la liste de MyNewLog (ou MyLogFile1 si vous avez suivi la procédure pour ajouter des arguments de ligne de commande) et développez-la. Vous devriez voir les entrées des actions (démarrage et arrêt) effectuées par votre service.

   

Nettoyer les ressources

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

1. Ouvrez l’invite de commandes du développeur pour Visual Studio avec des droits administratifs.

2. Dans la fenêtre Invite de commandes développeur pour Visual Studio , accédez au dossier qui contient l’exécutable de votre projet.

3. Entrez la commande suivante :

   installutil.exe /u MyNewService.exe
   

   Si le service se désinstalle correctement, la commande signale que votre service a été supprimé. Pour plus d’informations, consultez Guide pratique pour installer et désinstaller des services.

Prochaines étapes

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

• Créez un programme d’installation autonome que d’autres utilisateurs utilisent pour installer votre service Windows. Utilisez l’ensemble d’outils WiX pour créer un programme d’installation pour un service Windows. Pour d’autres idées, consultez Créer un package d’installation.

• Explorez le ServiceController composant, qui vous permet d’envoyer des commandes au service que vous avez installé.

• Au lieu de créer le journal des événements lorsque l’application s’exécute, utilisez un programme d’installation pour créer un journal des événements lorsque vous installez l’application. Le journal des événements est supprimé par le programme d’installation lorsque vous désinstallez l’application. Pour plus d’informations, consultez EventLogInstaller.

Voir aussi

• Applications de service Windows
• Présentation des applications de service Windows
• Guide pratique pour déboguer des applications de service Windows
• Services (Windows)