ServiceInstaller Classe

Definizione

Spazio dei nomi:

System.ServiceProcess

Assembly:

System.ServiceProcess.dll

Installa una classe che estende ServiceBase per implementare un servizio. Questa classe viene chiamata dall'utilità di installazione durante l'installazione di un'applicazione di servizio.

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

Ereditarietà

Object

MarshalByRefObject

Component

Installer

ComponentInstaller

ServiceInstaller

Esempio

Nell'esempio seguente viene creato un programma di installazione del progetto, denominato MyProjectInstaller, che eredita da Installer. Si presuppone che sia presente un eseguibile del servizio che contiene due servizi, "Hello-World Service 1" e "Hello-World Service 2". All'interno del costruttore per MyProjectInstaller (che verrebbe chiamato dall'utilità di installazione), ServiceInstaller gli oggetti vengono creati per ognuno di questi servizi e viene creato un ServiceProcessInstaller oggetto per l'eseguibile. Per l'utilità di installazione da riconoscere MyProjectInstaller come programma di installazione valido, l'attributo RunInstallerAttribute è impostato su true.

Le proprietà facoltative vengono impostate nel programma di installazione del processo e nei programmi di installazione del servizio prima che i programmi di installazione vengano aggiunti alla Installers raccolta. Quando l'utilità Installers di installazione accede MyProjectInstallera , gli oggetti aggiunti alla raccolta tramite una chiamata a InstallerCollection.Add verranno installati a sua volta. Durante il processo, il programma di installazione gestisce le informazioni sullo stato che indicano quali oggetti sono stati installati, in modo che ognuno possa essere sottoposto a backup a sua volta, se si verifica un errore di installazione.

In genere, non si creerebbe un'istanza della classe del programma di installazione del progetto in modo esplicito. Si creerebbe e si aggiungerà l'attributo alla sintassi, ma è l'utilità di installazione che in realtà chiama, e quindi crea un'istanza RunInstallerAttribute , 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

Commenti

Il ServiceInstaller servizio funziona in modo specifico per il servizio a cui è associato. Viene usato dall'utilità di installazione per scrivere valori del Registro di sistema associati al servizio a una sottochiave all'interno della chiave del Registro di sistema HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services. Il servizio viene identificato dal nome servizio all'interno di questa sottochiave. La sottochiave include anche il nome dell'eseguibile o del .dll a cui appartiene il servizio.

Per installare un servizio, creare una classe del programma di installazione del progetto che eredita dalla Installer classe e impostare l'attributo RunInstallerAttribute sulla classe su true. All'interno del progetto creare un'istanza ServiceProcessInstaller per ogni applicazione di servizio e un'istanza ServiceInstaller per ogni servizio nell'applicazione. All'interno del costruttore della classe del programma di installazione del progetto impostare le proprietà di installazione per il servizio usando le ServiceProcessInstaller istanze e ServiceInstaller e aggiungere le istanze alla Installers raccolta.

Nota

È consigliabile usare il costruttore per aggiungere istanze del programma di installazione; Tuttavia, se è necessario aggiungere alla Installers raccolta nel Install metodo, assicurarsi di eseguire le stesse aggiunte alla raccolta nel Uninstall metodo.

Per tutte le classi derivate dalla Installer classe, lo stato della Installers raccolta deve essere lo stesso nei Install metodi e Uninstall . Tuttavia, è possibile evitare la manutenzione della raccolta tra i Install metodi e Uninstall se si aggiungono istanze del programma di installazione alla Installers raccolta nel costruttore della classe di installazione personalizzata. Quando viene chiamata l'utilità di installazione, cerca l'attributo RunInstallerAttribute . Se l'attributo è true, l'utilità installa tutti i servizi aggiunti alla raccolta associata al Installers programma di installazione del progetto. Se RunInstallerAttribute è false o non esiste, l'utilità di installazione ignora il programma di installazione del progetto.

L'oggetto ServiceProcessInstaller associato alla classe di installazione del progetto installa le informazioni comuni a tutte le ServiceInstaller istanze del progetto. Se questo servizio contiene elementi che lo separano dagli altri servizi nel progetto di installazione, tali informazioni specifiche del servizio vengono installate da questo metodo.

Nota

È fondamentale che l'essere ServiceName identico all'oggetto ServiceBase.ServiceName della classe derivata da ServiceBase. In genere, il valore della proprietà per il servizio è impostato all'interno della ServiceBase.ServiceName funzione Main() dell'eseguibile dell'applicazione di servizio. Service Control Manager usa la proprietà per individuare il ServiceInstaller.ServiceName servizio all'interno di questo eseguibile.

È possibile modificare altre proprietà nell'oggetto ServiceInstaller prima o dopo l'aggiunta Installers alla raccolta del programma di installazione del progetto. Ad esempio, un servizio StartType può essere impostato per avviare automaticamente il servizio al riavvio o richiedere a un utente di avviare manualmente il servizio.

In genere, non si chiamano i metodi ServiceInstaller all'interno del codice. In genere vengono chiamati solo dall'utilità di installazione. L'utilità di installazione chiama automaticamente i ServiceProcessInstaller.Install metodi e ServiceInstaller.Install durante il processo di installazione. Esegue il backup degli errori, se necessario, chiamando Rollback (o ServiceInstaller.Rollback) in tutti i componenti installati in precedenza.

L'utilità di installazione chiama Uninstall per rimuovere l'oggetto.

La routine di installazione di un'applicazione gestisce automaticamente le informazioni sui componenti già installati, usando il programma di installazione del Installer.Contextprogetto . Queste informazioni sullo stato vengono aggiornate continuamente come ServiceProcessInstaller istanza e ogni ServiceInstaller istanza viene installata dall'utilità . In genere non è necessario che il codice modifichi in modo esplicito le informazioni sullo stato.

Quando viene eseguita l'installazione, crea automaticamente un oggetto EventLogInstaller per installare l'origine del registro eventi associata alla ServiceBase classe derivata. La Log proprietà per questa origine viene impostata dal ServiceInstaller costruttore sul registro applicazioni del computer. Quando si imposta l'oggetto ServiceName di ServiceInstaller (che deve essere identico a quello ServiceBase.ServiceName del servizio), l'oggetto Source viene impostato automaticamente sullo stesso valore. In un errore di installazione, viene eseguito il rollback dell'installazione dell'origine insieme ai servizi installati in precedenza.

Il Uninstall metodo tenta di arrestare il servizio se è in esecuzione. Se l'operazione ha esito positivo o negativo, Uninstall annulla le modifiche apportate da Install. Se è stata creata una nuova origine per la registrazione eventi, l'origine viene eliminata.

Costruttori

ServiceInstaller()

Inizializza una nuova istanza della classe ServiceInstaller.

Proprietà

CanRaiseEvents	Ottiene un valore che indica se il componente può generare un evento. (Ereditato da Component)
Container	Ottiene l'oggetto IContainer che contiene Component. (Ereditato da Component)
Context	Ottiene o imposta le informazioni sull'installazione corrente. (Ereditato da Installer)
DelayedAutoStart	Ottiene o imposta un valore che indica se ritardare l'avvio del servizio fino all'esecuzione di altri servizi avviati automaticamente.
Description	Ottiene o imposta la descrizione del servizio.
DesignMode	Ottiene un valore che indica se il Component si trova in modalità progettazione. (Ereditato da Component)
DisplayName	Specifica il nome descrittivo visualizzato per consentire all'utente di identificare il servizio.
Events	Ottiene l'elenco dei gestori eventi allegati a questo Component. (Ereditato da Component)
HelpText	Ottiene il testo della Guida per tutti i programmi di installazione della raccolta Installer. (Ereditato da Installer)
Installers	Ottiene la raccolta dei programmi di installazione contenuti nel programma. (Ereditato da Installer)
Parent	Ottiene o imposta il programma di installazione contenente la raccolta cui appartiene questo programma di installazione. (Ereditato da Installer)
ServiceName	Specifica il nome utilizzato dal sistema per identificare il servizio. È necessario che questa proprietà sia identica alla proprietà ServiceName del servizio che si desidera installare.
ServicesDependedOn	Indica i servizi che è necessario che siano in esecuzione per eseguire questo servizio.
Site	Ottiene o imposta l'oggetto ISite di Component. (Ereditato da Component)
StartType	Specifica come e quando viene avviato questo servizio.

Metodi

Commit(IDictionary)	Quando ne viene eseguito l'override in una classe derivata, completa la transazione di installazione. (Ereditato da Installer)
CopyFromComponent(IComponent)	Copia le proprietà da un'istanza di ServiceBase in questo programma di installazione.
CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
Dispose()	Rilascia tutte le risorse usate da Component. (Ereditato da Component)
Dispose(Boolean)	Rilascia le risorse non gestite usate da Component e, facoltativamente, le risorse gestite. (Ereditato da Component)
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetService(Type)	Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container. (Ereditato da Component)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
Install(IDictionary)	Installa il servizio scrivendo le informazioni dell'applicazione di servizio nel Registro di sistema. È necessario che il metodo venga utilizzato dagli strumenti di installazione che elaborano automaticamente i metodi corretti.
IsEquivalentInstaller(ComponentInstaller)	Indica se l'installazione di uno stesso servizio viene eseguita da due programmi di installazione.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
OnAfterInstall(IDictionary)	Genera l'evento AfterInstall. (Ereditato da Installer)
OnAfterRollback(IDictionary)	Genera l'evento AfterRollback. (Ereditato da Installer)
OnAfterUninstall(IDictionary)	Genera l'evento AfterUninstall. (Ereditato da Installer)
OnBeforeInstall(IDictionary)	Genera l'evento BeforeInstall. (Ereditato da Installer)
OnBeforeRollback(IDictionary)	Genera l'evento BeforeRollback. (Ereditato da Installer)
OnBeforeUninstall(IDictionary)	Genera l'evento BeforeUninstall. (Ereditato da Installer)
OnCommitted(IDictionary)	Genera l'evento Committed. (Ereditato da Installer)
OnCommitting(IDictionary)	Genera l'evento Committing. (Ereditato da Installer)
Rollback(IDictionary)	Annulla le informazioni dell'applicazione di servizio scritte nel Registro di sistema dalla procedura di installazione. È necessario che il metodo venga utilizzato dagli strumenti di installazione che elaborano automaticamente i metodi corretti.
ToString()	Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component. Questo metodo non deve essere sottoposto a override. (Ereditato da Component)
Uninstall(IDictionary)	Disinstalla il servizio rimuovendo dal Registro di sistema le informazioni relative.

Eventi

AfterInstall	Si verifica dopo l'esecuzione dei metodi Install(IDictionary) di tutti i programmi di installazione contenuti nella proprietà Installers. (Ereditato da Installer)
AfterRollback	Si verifica dopo il rollback delle installazioni di tutti i programmi di installazione contenuti nella proprietà Installers. (Ereditato da Installer)
AfterUninstall	Si verifica dopo l'esecuzione delle operazioni di disinstallazione di tutti i programmi di installazione contenuti nella proprietà Installers. (Ereditato da Installer)
BeforeInstall	Si verifica dopo l'esecuzione del metodo Install(IDictionary) di ogni programma di installazione contenuto nella raccolta Installer. (Ereditato da Installer)
BeforeRollback	Si verifica prima del rollback dei programmi di installazione contenuti nella proprietà Installers. (Ereditato da Installer)
BeforeUninstall	Si verifica prima dell'esecuzione delle operazioni di disinstallazione dei programmi di installazione contenuti nella proprietà Installers. (Ereditato da Installer)
Committed	Si verifica dopo l'esecuzione del commit delle installazioni di tutti i programmi di installazione contenuti nella proprietà Installers. (Ereditato da Installer)
Committing	Si verifica prima dell'esecuzione del commit delle installazioni dei programmi di installazione contenuti nella proprietà Installers. (Ereditato da Installer)
Disposed	Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose(). (Ereditato da Component)

Vedi anche

• ServiceName
• ServiceProcessInstaller
• ServiceBase
• EventLog