ServiceInstaller Classe

Définition

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 les objets sont créés pour chacun de ces services, et un ServiceProcessInstaller est créé pour l’exécutable. Pour que l’utilitaire d’installation reconnaisse 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 de service avant l’ajout des programmes d’installation à la Installers collection. Lorsque l’utilitaire d’installation accède, les objets ajoutés MyProjectInstallerà la Installers collection par le biais d’un appel seront 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, afin que chacun puisse être sauvegardé à son tour, si une défaillance d’installation se produit.

Normalement, vous ne créez pas explicitement une instance de votre classe d’installation de projet. Vous le créez et ajoutez l’attribut RunInstallerAttribute à la syntaxe, mais il s’agit de l’utilitaire d’installation qui appelle réellement, et instancie donc 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 travail est 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é au sein de 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 .dll auquel appartient le service.

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 ajoutez les instances à la Installers collection.

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

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

Vous pouvez modifier d’autres propriétés avant ServiceInstaller ou après l’avoir ajoutée à la Installers collection de votre programme d’installation de projet. Par exemple, les services StartType peuvent être définis pour démarrer le service automatiquement 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 méthodes et ServiceInstaller.Install les ServiceProcessInstaller.Install méthodes pendant le processus d’installation. Elle sauvegarde les défaillances, si nécessaire, en appelant Rollback (ou ServiceInstaller.Rollback) sur tous les composants précédemment installés.

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

La routine d’installation d’une application gère automatiquement les informations sur les composants déjà installés, à l’aide du programme d’installation du Installer.Contextprojet. Ces informations d’état sont mises à jour en permanence en tant qu’instance ServiceProcessInstaller , et chaque ServiceInstaller instance est installée par l’utilitaire. Il est généralement inutile que votre code modifie explicitement les informations d’état.

Lorsque l’installation est effectuée, elle crée automatiquement une 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 dans le journal d’application de l’ordinateur. Lorsque vous définissez le ServiceNameServiceInstaller (qui doit être identique au ServiceBase.ServiceName service), il 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.

Voir aussi

• ServiceName
• ServiceProcessInstaller
• ServiceBase
• EventLog