Écriture d'un programme de service Win2000 à l'aide de Delphi
Résumé : Cet article présente l'utilisation de Delphi pour écrire des programmes de service Win2000. Les classes impliquées sont TServiceApplicatoin, TService, TServiceThread, etc.
Mots-clés : Service/service
1. Introduction aux services Win2000
L'application de service est un programme d'arrière-plan exécuté sur WinNT. Chaque application de service peut contenir plusieurs services et chaque service est l'un des threads (le service peut également créer plusieurs sous-services). En utilisant les services, les applications peuvent obtenir des autorisations spéciales et l'utilisateur ne terminera pas directement le programme via le gestionnaire de tâches Win2000. Les services sont donc souvent utilisés pour atteindre certains objectifs particuliers.
Grâce à l'outil de gestion des services dans le panneau de configuration Win2000, nous pouvons définir/afficher les caractéristiques du service :
(1) Nom du service ; (2) Nom d'affichage ; (3) Description (4) Type de démarrage ;
Parmi eux, le nom du service identifie le service.
Prenons comme exemple le programme C:/WINNT/System32/services.exe de Win2000. Ce fichier Exe correspond à une application de service et est l'entité visible du programme de service qui contient plusieurs services (Service), tels que Alerter, Client DHCP (DHCP)), Messenger, etc. Lorsque nous mettons fin à un service, les autres services de l'application de service où se trouve le service ne sont pas résiliés.
Dans Delphi, les ingénieurs Borland nous fournissent TServiceApplication, TService, TServiceThread et d'autres classes, qui encapsulent un grand nombre de détails et simplifient le développement de programmes de service.
2. TServiceApplication
Dans Delphi, la classe TServiceApplication correspond à la ServiceApplication mentionnée ci-dessus. À l'aide de l'environnement de développement Delphi, nous créons un nouveau projet d'application de service et créons une classe héritée de TService. L'objet Application dans le fichier projet est une instance de TServiceApplication. Chaque TServiceApplication contient plusieurs objets TService, qui correspondent exactement à la relation quantitative mentionnée ci-dessus entre les programmes de service et les services.
En lisant les définitions des classes TServiceApplication et TService, on peut savoir que TServiceApplication hérite de la classe TComponent, que TService vient de la classe TDataModule et que l'objet Application est responsable de la création et de la destruction de chaque objet TService. Suivez le code suivant
Application.CreateForm(TService1, Service1);
On peut constater que les propriétaires des objets TService créés sont tous des objets Application ; dans VCL FrameWork, le propriétaire est toujours responsable de la destruction de chaque objet Component (la classe TComponent de VCL adopte le mode Composite), donc TServiceApplication détruira également chaque objet TService.
En suivant le code de TServiceApplication.Run, vous pouvez constater que TServiceApplication analyse d'abord les paramètres en cours d'exécution et implémente l'installation et la désinstallation du service. Ensuite, initialisez un tableau ServiceStartTable, qui contient le nom du service et l'entrée en cours de chaque objet de service ; créez enfin un objet TServiceStartThread, qui est un objet thread, et appelez l'API : StartServiceCtrlDispatcher à partir du thread pour démarrer plusieurs services spécifiés dans ServiceStartTable ; Le thread principal ServiceApplication continue de boucler et de traiter les messages, tels que la réception de demandes d'arrêt/de pause d'un service.
3. TService
La classe TService hérite de la classe TDataModule, ce qui signifie que l'on peut ajouter un grand nombre de contrôles VCL pour réaliser des fonctions riches. De plus, nous pouvons également gérer OnStart, OnPause, OnStop, OnContinue, OnCreate, OnShutDown et d'autres événements. Ce qu'il faut expliquer, c'est : OnStop signifie que le service a été arrêté ; et OnShutDown signifie que ServiceApplication a cessé de fonctionner, ce qui signifie que d'autres services ont également été arrêtés ; les significations des deux sont différentes ;
Comme mentionné précédemment, ServiceApplication démarre chaque service en appelant StartServiceCtrlDispatcher. StartServiceCtrlDispatcher démarre l'entrée de TService, qui est TService.Main. TService.Main enregistre d'abord le service, puis appelle TService.DoStart. TService.DoStart crée un objet membre TServiceThread interne, qui est un objet thread ; en examinant TServiceThread.Execute, nous pouvons savoir que lorsque nous traitons TService1.OnExecute, alors TService déléguera toutes les demandes à l'objet membre TServiceThread pour le traitement. La méthode par défaut gère toutes les requêtes.
TService. ServiceExecute est le contenu principal de TService. Pour qu'un service fonctionne normalement, en plus de répondre aux objectifs sur lesquels il doit se concentrer (comme écouter un certain port, effectuer une certaine tâche, etc.), il doit également répondre à des commandes/requêtes externes : telles que mettre fin, suspendre et reprendre le service. Par conséquent, vous pouvez envisager de créer un thread dédié pour effectuer cette tâche et gérer les commandes/demandes externes dans ServiceExecute. Le code est donc le suivant :
même s'il n'est pas terminé, il commence
ServiceThread.ProcessRequests(False);
fin;
Bien sûr, vous pouvez également gérer certaines tâches dans OnExecute, comme écouter un certain port, mais cela a souvent pour conséquence que le service n'est pas en mesure de répondre aux demandes d'arrêt/pause et autres en temps opportun. Lorsque OnExecute est terminé, le service a effectivement terminé sa tâche et est sur le point de se terminer (terminer).
Références :
MSDN, code source Delphi VCL, documentation d'aide Delphi