Partager via

ServiceInstaller Classe

  • Référence

Définition

Espace de noms:
System.ServiceProcess
Assembly:
System.ServiceProcess.dll

Installe une classe qui étend ServiceBase pour implémenter un service. Cette classe est appelée par l'utilitaire d'installation lors de l'installation d'une application de service.

public ref class ServiceInstaller : System::Configuration::Install::ComponentInstaller
public class ServiceInstaller : System.Configuration.Install.ComponentInstaller
type ServiceInstaller = class
    inherit ComponentInstaller
Public Class ServiceInstaller
Inherits ComponentInstaller
Héritage
Object
MarshalByRefObject
Component
Installer
ComponentInstaller
ServiceInstaller

Exemples

L’exemple suivant crée un programme d’installation de projet, appelé MyProjectInstaller, qui hérite de Installer. Il est supposé qu’il existe un exécutable de service qui contient deux services, « Hello-World Service 1 » et « Hello-World Service 2 ». Dans le constructeur pour MyProjectInstaller (qui serait appelé par l’utilitaire d’installation), ServiceInstaller des objets sont créés pour chacun de ces services, et un ServiceProcessInstaller est créé pour l’exécutable. Pour que l’utilitaire d’installation soit reconnu MyProjectInstaller comme programme d’installation valide, l’attribut RunInstallerAttribute est défini sur true.

Les propriétés facultatives sont définies sur le programme d’installation du processus et les programmes d’installation du service avant que les programmes d’installation ne soient ajoutés à la Installers collection. Lorsque l’utilitaire d’installation accède à , les objets ajoutés MyProjectInstallerà la Installers collection via un appel à sont installés à InstallerCollection.Add leur tour. Pendant le processus, le programme d’installation conserve les informations d’état indiquant quels objets ont été installés, de sorte que chacun d’eux peut être annulé à son tour, en cas d’échec de l’installation.

Normalement, vous ne créez pas explicitement de instance de la classe du programme d’installation de votre projet. Vous devez le créer et ajouter l’attribut RunInstallerAttribute à la syntaxe, mais c’est l’utilitaire d’installation qui appelle réellement, et donc instancie, la classe.

#using <System.dll>
#using <System.ServiceProcess.dll>
#using <System.Configuration.Install.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Configuration::Install;
using namespace System::ServiceProcess;
using namespace System::ComponentModel;

[RunInstaller(true)]
public ref class MyProjectInstaller : public Installer
{
private:
    ServiceInstaller^ serviceInstaller1;
    ServiceInstaller^ serviceInstaller2;
    ServiceProcessInstaller^ processInstaller;

public:
    MyProjectInstaller()
    {
        // Instantiate installers for process and services.
        processInstaller = gcnew ServiceProcessInstaller;
        serviceInstaller1 = gcnew ServiceInstaller;
        serviceInstaller2 = gcnew ServiceInstaller;

        // The services run under the system account.
        processInstaller->Account = ServiceAccount::LocalSystem;

        // The services are started manually.
        serviceInstaller1->StartType = ServiceStartMode::Manual;
        serviceInstaller2->StartType = ServiceStartMode::Manual;

        // ServiceName must equal those on ServiceBase derived classes.
        serviceInstaller1->ServiceName = "Hello-World Service 1";
        serviceInstaller2->ServiceName = "Hello-World Service 2";

        // Add installers to collection. Order is not important.
        Installers->Add( serviceInstaller1 );
        Installers->Add( serviceInstaller2 );
        Installers->Add( processInstaller );
    }

    static void Main()
    {
        Console::WriteLine("Usage: InstallUtil.exe [<service>.exe]");
    }
};

int main()
{
    MyProjectInstaller::Main();
}

using System;
using System.Collections;
using System.Configuration.Install;
using System.ServiceProcess;
using System.ComponentModel;

[RunInstaller(true)]
public class MyProjectInstaller : Installer
{
    private ServiceInstaller serviceInstaller1;
    private ServiceInstaller serviceInstaller2;
    private ServiceProcessInstaller processInstaller;

    public MyProjectInstaller()
    {
        // Instantiate installers for process and services.
        processInstaller = new ServiceProcessInstaller();
        serviceInstaller1 = new ServiceInstaller();
        serviceInstaller2 = new ServiceInstaller();

        // The services run under the system account.
        processInstaller.Account = ServiceAccount.LocalSystem;

        // The services are started manually.
        serviceInstaller1.StartType = ServiceStartMode.Manual;
        serviceInstaller2.StartType = ServiceStartMode.Manual;

        // ServiceName must equal those on ServiceBase derived classes.
        serviceInstaller1.ServiceName = "Hello-World Service 1";
        serviceInstaller2.ServiceName = "Hello-World Service 2";

        // Add installers to collection. Order is not important.
        Installers.Add(serviceInstaller1);
        Installers.Add(serviceInstaller2);
        Installers.Add(processInstaller);
    }

    public static void Main()
    {
        Console.WriteLine("Usage: InstallUtil.exe [<service>.exe]");
    }
}

Imports System.Collections
Imports System.Configuration.Install
Imports System.ServiceProcess
Imports System.ComponentModel

<RunInstallerAttribute(True)> _
Public Class MyProjectInstaller
    Inherits Installer
    Private serviceInstaller1 As ServiceInstaller
    Private serviceInstaller2 As ServiceInstaller
    Private processInstaller As ServiceProcessInstaller    
    
    Public Sub New()
        ' Instantiate installers for process and services.
        processInstaller = New ServiceProcessInstaller()
        serviceInstaller1 = New ServiceInstaller()
        serviceInstaller2 = New ServiceInstaller()
        
        ' The services will run under the system account.
        processInstaller.Account = ServiceAccount.LocalSystem
        
        ' The services will be started manually.
        serviceInstaller1.StartType = ServiceStartMode.Manual
        serviceInstaller2.StartType = ServiceStartMode.Manual
        
        ' ServiceName must equal those on ServiceBase derived classes.            
        serviceInstaller1.ServiceName = "Hello-World Service 1"
        serviceInstaller2.ServiceName = "Hello-World Service 2"
        
        ' Add installers to collection. Order is not important.
        Installers.Add(serviceInstaller1)
        Installers.Add(serviceInstaller2)
        Installers.Add(processInstaller)
    End Sub

    Public Shared Sub Main()
        Console.WriteLine("Usage: InstallUtil.exe [<service>.exe]")
    End Sub
End Class

Remarques

Le ServiceInstaller fonctionne spécifique au service auquel il est associé. Il est utilisé par l’utilitaire d’installation pour écrire des valeurs de Registre associées au service dans une sous-clé dans la clé de Registre HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services. Le service est identifié par son ServiceName dans cette sous-clé. La sous-clé inclut également le nom de l’exécutable ou de l'.dll auquel le service appartient.

Pour installer un service, créez une classe de programme d’installation de projet qui hérite de la Installer classe et définissez l’attribut RunInstallerAttribute sur la classe truesur . Dans votre projet, créez une ServiceProcessInstaller instance par application de service et une ServiceInstaller instance pour chaque service de l’application. Dans le constructeur de classe du programme d’installation de votre projet, définissez les propriétés d’installation du service à l’aide des ServiceProcessInstaller instances et ServiceInstaller et ajoutez les instances à la Installers collection.

Notes

Il est recommandé d’utiliser le constructeur pour ajouter des instances du programme d’installation ; Toutefois, si vous devez ajouter à la Installers collection dans la Install méthode, veillez à effectuer les mêmes ajouts à la collection dans la Uninstall méthode.

Pour toutes les classes dérivées de la Installer classe, l’état de la Installers collection doit être le même dans les Install méthodes et Uninstall . Toutefois, vous pouvez éviter la maintenance de la collection entre les Install méthodes et Uninstall si vous ajoutez des instances de programme d’installation à la Installers collection dans votre constructeur de classe d’installation personnalisé. Lorsque l’utilitaire d’installation est appelé, il recherche l’attribut RunInstallerAttribute . Si l’attribut est true, l’utilitaire installe tous les services qui ont été ajoutés à la Installers collection qui ont été associés au programme d’installation de votre projet. Si RunInstallerAttribute est ou n’existe false pas, l’utilitaire d’installation ignore le programme d’installation du projet.

Le ServiceProcessInstaller associé à votre classe d’installation de projet installe les informations communes à toutes les ServiceInstaller instances du projet. Si ce service a quelque chose qui le sépare des autres services dans le projet d’installation, ces informations spécifiques au service sont installées par cette méthode.

Notes

Il est essentiel que le ServiceName soit identique au ServiceBase.ServiceName de la classe que vous avez dérivée de ServiceBase. Normalement, la valeur de la ServiceBase.ServiceName propriété pour le service est définie dans la fonction Main() du fichier exécutable de l’application de service. Le Gestionnaire de contrôle de service utilise la ServiceInstaller.ServiceName propriété pour localiser le service dans cet exécutable.

Vous pouvez modifier d’autres propriétés sur le avant ou après l’avoir ServiceInstaller ajouté à la Installers collection de votre programme d’installation de projet. Par exemple, un service StartType peut être configuré pour démarrer automatiquement le service au redémarrage ou exiger qu’un utilisateur démarre le service manuellement.

Normalement, vous n’appelez pas les méthodes dans ServiceInstaller votre code ; elles sont généralement appelées uniquement par l’utilitaire d’installation. L’utilitaire d’installation appelle automatiquement les ServiceProcessInstaller.Install méthodes et ServiceInstaller.Install pendant le processus d’installation. Il effectue une sauvegarde des échecs, si nécessaire, en appelant Rollback (ou ServiceInstaller.Rollback) sur tous les composants installés précédemment.

L’utilitaire d’installation appelle Uninstall pour supprimer l’objet.

La routine d’installation d’une application conserve automatiquement les informations sur les composants déjà installés, à l’aide du programme d’installation du Installer.Contextprojet . Ces informations d’état sont continuellement mises à jour au fur et à mesure que le ServiceProcessInstaller instance, et chaque ServiceInstaller instance est installé par l’utilitaire. Il n’est généralement pas nécessaire que votre code modifie explicitement les informations d’état.

Lorsque l’installation est effectuée, il crée automatiquement un pour installer la source du journal des EventLogInstaller événements associée à la ServiceBase classe dérivée. La Log propriété de cette source est définie par le ServiceInstaller constructeur sur le journal des applications de l’ordinateur. Lorsque vous définissez le ServiceName de ( ServiceInstaller qui doit être identique à celui ServiceBase.ServiceName du service), le Source est automatiquement défini sur la même valeur. En cas d’échec d’installation, l’installation de la source est restaurée avec les services précédemment installés.

La Uninstall méthode tente d’arrêter le service s’il est en cours d’exécution. Que cela réussisse ou non, Uninstall annule les modifications apportées par Install. Si une nouvelle source a été créée pour la journalisation des événements, la source est supprimée.

Constructeurs

ServiceInstaller()

Initialise une nouvelle instance de la classe ServiceInstaller.

Propriétés

CanRaiseEvents

Obtient une valeur qui indique si le composant peut déclencher un événement.

(Hérité de Component)
Container

Obtient le IContainer qui contient la Component.

(Hérité de Component)
Context

Obtient ou définit des informations sur l'installation en cours.

(Hérité de Installer)
DelayedAutoStart

Obtient ou définit une valeur qui indique si le démarrage du service doit être différé jusqu'à ce que d'autres services démarrés automatiquement soit en cours d'exécution.
Description

Obtient ou définit la description du service.
DesignMode

Obtient une valeur qui indique si Component est actuellement en mode design.

(Hérité de Component)
DisplayName

Indique le nom convivial qui identifie le service offert à l'utilisateur.
Events

Obtient la liste des gestionnaires d'événements attachés à ce Component.

(Hérité de Component)
HelpText

Obtient le texte d’aide pour tous les programmes d’installation de la collection de programmes d’installation.

(Hérité de Installer)
Installers

Obtient la collection de programmes d’installation contenue dans ce programme d’installation.

(Hérité de Installer)
Parent

Obtient ou définit le programme d'installation contenant la collection à laquelle appartient ce programme d'installation.

(Hérité de Installer)
ServiceName

Indique le nom utilisé par le système pour identifier ce service. Cette propriété doit être identique à la propriété ServiceName du service que vous souhaitez installer.
ServicesDependedOn

Indique les services qui doivent être en cours d'exécution pour que ce service puisse fonctionner.
Site

Obtient ou définit le ISite de Component.

(Hérité de Component)
StartType

Indique le mode de démarrage de ce service.

Méthodes

Commit(IDictionary)

En cas de substitution dans une classe dérivée, termine la transaction d’installation.

(Hérité de Installer)
CopyFromComponent(IComponent)

Copie les propriétés d'une instance de ServiceBase vers ce programme d'installation.
CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.

(Hérité de MarshalByRefObject)
Dispose()

Libère toutes les ressources utilisées par Component.

(Hérité de Component)
Dispose(Boolean)

Libère les ressources non managées utilisées par Component et libère éventuellement les ressources managées.

(Hérité de Component)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetLifetimeService()
Obsolète.

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
GetService(Type)

Retourne un objet qui représente un service fourni par Component ou par son Container.

(Hérité de Component)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
InitializeLifetimeService()
Obsolète.

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
Install(IDictionary)

Installe le service en écrivant les informations relatives aux applications de service dans le Registre. Cette méthode est destinée à être utilisée par les outils d'installation qui traitent automatiquement les méthodes appropriées.
IsEquivalentInstaller(ComponentInstaller)

Indique si deux programmes d'installation installent le même service.
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.

(Hérité de MarshalByRefObject)
OnAfterInstall(IDictionary)

Déclenche l’événement AfterInstall.

(Hérité de Installer)
OnAfterRollback(IDictionary)

Déclenche l’événement AfterRollback.

(Hérité de Installer)
OnAfterUninstall(IDictionary)

Déclenche l’événement AfterUninstall.

(Hérité de Installer)
OnBeforeInstall(IDictionary)

Déclenche l’événement BeforeInstall.

(Hérité de Installer)
OnBeforeRollback(IDictionary)

Déclenche l’événement BeforeRollback.

(Hérité de Installer)
OnBeforeUninstall(IDictionary)

Déclenche l’événement BeforeUninstall.

(Hérité de Installer)
OnCommitted(IDictionary)

Déclenche l’événement Committed.

(Hérité de Installer)
OnCommitting(IDictionary)

Déclenche l’événement Committing.

(Hérité de Installer)
Rollback(IDictionary)

Restaure les informations de l'application de service inscrites dans le Registre par la procédure d'installation. Cette méthode est destinée à être utilisée par les outils d'installation qui traitent automatiquement les méthodes appropriées.
ToString()

Retourne un String contenant le nom du Component, s’il en existe un. Cette méthode ne doit pas être remplacée.

(Hérité de Component)
Uninstall(IDictionary)

Désinstalle le service en supprimant les informations qui le concernent dans le Registre.

Événements

AfterInstall

Se produit après l'exécution des méthodes Install(IDictionary) de tous les programmes d'installation de la propriété Installers.

(Hérité de Installer)
AfterRollback

Se produit après la restauration des installations de tous les programmes d'installation de la propriété Installers.

(Hérité de Installer)
AfterUninstall

Se produit une fois que tous les programmes d'installation de la propriété Installers ont effectué leurs propres opérations de désinstallation.

(Hérité de Installer)
BeforeInstall

Se produit avant l’exécution de la méthode Install(IDictionary) de chaque programme d’installation contenu dans la collection de programmes d’installation.

(Hérité de Installer)
BeforeRollback

Se produit avant la restauration des programmes d'installation de la propriété Installers.

(Hérité de Installer)
BeforeUninstall

Se produit avant que les programmes d'installation de la propriété Installers aient effectué leurs propres opérations de désinstallation.

(Hérité de Installer)
Committed

Se produit après la validation de l'installation de tous les programmes d'installation de la propriété Installers.

(Hérité de Installer)
Committing

Se produit avant la validation de l’installation des programmes d’installation de la propriété Installers.

(Hérité de Installer)
Disposed

Se produit lorsque le composant est supprimé par un appel à la méthode Dispose().

(Hérité de Component)

S’applique à

Voir aussi