Evaluar y enviar comentarios

  Encender vista de ancho de banda bajo
Esta página es específica de
Microsoft Visual Studio 2005/.NET Framework 2.0

Hay además otras versiones disponibles para:
Biblioteca de clases de .NET Framework
ServiceInstaller (Clase)

Instala una clase que extiende ServiceBase para implementar un servicio. La utilidad de instalación llama a esta clase al instalar una aplicación de servicio.

Espacio de nombres: System.ServiceProcess
Ensamblado: System.ServiceProcess (en system.serviceprocess.dll)

Visual Basic (Declaración)
Public Class ServiceInstaller
    Inherits ComponentInstaller
Visual Basic (Uso)
Dim instance As ServiceInstaller
C#
public class ServiceInstaller : ComponentInstaller
C++
public ref class ServiceInstaller : public ComponentInstaller
J#
public class ServiceInstaller extends ComponentInstaller
JScript
public class ServiceInstaller extends ComponentInstaller

ServiceInstaller no funciona de forma específica respecto al servicio al que está asociado. La utilidad de instalación lo utiliza para escribir valores del Registro asociados al servicio en una subclave dentro de la clave de Registro HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services. El servicio se identifica mediante su propiedad ServiceName dentro de esta subclave. La subclave incluye también el nombre del ejecutable o archivo .dll al que pertenece el servicio.

Para instalar un servicio, cree una clase de instalador del proyecto que se herede de la clase Installer, y establezca el atributo RunInstallerAttribute de la clase en true. Dentro del proyecto, cree una instancia de ServiceProcessInstaller por aplicación de servicio y una instancia de ServiceInstaller por cada servicio de aplicación. Dentro del constructor de clase de instalador del proyecto, establezca las propiedades de instalación del servicio utilizando las instancias de ServiceProcessInstaller y ServiceInstaller y agregue las instancias a la colección Installers.

NotaNota

   Se recomienda que utilice el constructor para agregar instancias del instalador; no obstante, si tiene que agregar a la colección Installers del método Install, asegúrese de realizar las mismas agregaciones a la colección del método Uninstall.

Para todas las clases que derivan de la clase Installer, el estado de la colección Installers debe ser igual en los métodos Install y Uninstall. No obstante, se puede impedir el mantenimiento de la colección en los métodos Install y Uninstall si se agregan instancias del instalador a la colección Installers en el constructor de clase del instalador personalizado. Cuando se llama a la utilidad de instalación, se busca el atributo RunInstallerAttribute. Si el valor del atributo es true, la utilidad instala todos los servicios que se agregaron a la colección Installers asociados al instalador del proyecto. Si RunInstallerAttribute es false o no existe, la utilidad de instalación omite el instalador del proyecto.

El objeto ServiceProcessInstaller asociado a la clase de instalación del proyecto instala información común a todas las instancias de ServiceInstaller del proyecto. Si este servicio tiene algo que lo diferencia de los demás servicios del proyecto de instalación, este método instala esa información específica del servicio.

NotaNota

Es fundamental que la propiedad ServiceName sea idéntica a la propiedad ServiceBase.ServiceName de la clase que se derivó de ServiceBase. Normalmente, el valor de la propiedad ServiceBase.ServiceName del servicio está establecido en la función Main() del ejecutable de la aplicación de servicio. El Administrador de control de servicios utiliza la propiedad ServiceInstaller.ServiceName para buscar el servicio en este ejecutable.

Puede modificar otras propiedades de ServiceInstaller antes o después de agregarlo a la colección Installers del instalador del proyecto. Por ejemplo, se puede establecer la propiedad StartType de un servicio de manera que inicie el servicio automáticamente al reiniciar o que, por el contrario, requiera que un usuario inicie el servicio de forma manual.

Por lo general, no se llamará a los métodos en ServiceInstaller dentro del código; se suelen llamar sólo desde la utilidad de instalación. La utilidad de instalación llama de forma automática a los métodos ServiceProcessInstaller.Install y ServiceInstaller.Install durante el proceso de instalación. Deshace los errores, si es necesario, mediante una llamada a Rollback (o ServiceInstaller.Rollback) en todos los componentes instalados anteriormente.

La utilidad de instalación llama a Uninstall para que quite el objeto.

La rutina de instalación de una aplicación mantiene de forma automática la información acerca de los componentes que ya se han instalado mediante la propiedad Installer.Context del instalador del proyecto. Esta información de estado se actualiza continuamente a medida que la utilidad instala la instancia de ServiceProcessInstaller y cada una de las instancias de ServiceInstaller. No suele ser necesario que el código modifique esta información de estado de forma explícita.

Cuando se realiza la instalación, se crea de forma automática un EventLogInstaller para instalar el origen de registro de eventos asociado a la clase derivada de ServiceBase. La propiedad Log de este origen se establece mediante el constructor de ServiceInstaller en el registro de aplicación del equipo. Cuando se establece la propiedad ServiceName de ServiceInstaller, que tiene que ser idéntica a la propiedad ServiceBase.ServiceName del servicio, la propiedad Source se establece de forma automática en el mismo valor. En un error de instalación, la instalación del origen se deshace, junto con los servicios instalados anteriormente.

El método Uninstall intenta detener el servicio si éste se encuentra en ejecución. Tanto si lo consigue como si no, Uninstall deshace los cambios realizados por Install. Si se creó un nuevo origen para el registro de eventos, se elimina el origen.

En el siguiente ejemplo se crea un instalador del proyecto denominado MyProjectInstaller que hereda de Installer. Se supone que hay un ejecutable de servicio que contiene dos servicios: "Hello-World Service 1" y "Hello-World Service 2". En el constructor de MyProjectInstaller, al que llamaría la utilidad de instalación, se crean objetos ServiceInstaller para cada uno de estos servicios y se crea ServiceProcessInstaller para el ejecutable. Para que la utilidad de instalación reconozca MyProjectInstaller como un instalador válido, el atributo RunInstallerAttribute se establece en true.

Las propiedades opcionales se establecen en el instalador del proceso y los instaladores del servicio antes de que los instaladores se agreguen a la colección Installers. Cuando la utilidad de instalación obtiene acceso a MyProjectInstaller, los objetos agregados a la colección Installers se instalan uno a uno mediante una llamada a InstallerCollection.Add. Durante el proceso, el instalador mantiene información de estado que indica qué objetos se han instalado, de forma que puedan deshacerse uno a uno si se produce un error en la instalación.

Generalmente, no habrá que crear explícitamente una instancia de la clase de instalador del proyecto. Se crearía y se agregaría el atributo RunInstallerAttribute a la sintaxis, pero es la utilidad de instalación la que llama realmente a la clase y, por tanto, crea una instancia de ella.

Visual Basic
Imports System
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
End Class

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

[RunInstallerAttribute(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);
   }
}

C++
#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;

[RunInstallerAttribute(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 );
   }

};

J#
import System.*;
import System.Collections.*;
import System.Configuration.Install.*;
import System.ServiceProcess.*;
import System.ComponentModel.*;

/** @attribute RunInstallerAttribute(true)
 */
public class MyProjectInstaller extends 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.set_Account(ServiceAccount.LocalSystem);

        // The services are started manually.
        serviceInstaller1.set_StartType(ServiceStartMode.Manual);
        serviceInstaller2.set_StartType(ServiceStartMode.Manual);

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

        // Add installers to collection. Order is not important.
        get_Installers().Add(serviceInstaller1);
        get_Installers().Add(serviceInstaller2);
        get_Installers().Add(processInstaller);
    } //MyProjectInstaller
} //MyProjectInstaller
System.Object
   System.MarshalByRefObject
     System.ComponentModel.Component
       System.Configuration.Install.Installer
         System.Configuration.Install.ComponentInstaller
          System.ServiceProcess.ServiceInstaller
Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0
Contenido de la comunidad   ¿Qué es Community Content?
Agregar contenido nuevo RSS  Anotaciones
Processing
© 2009 Microsoft Corporation. Reservados todos los derechos. Términos de uso  |  Marcas Registradas  |  Privacidad
Page view tracker