Instalación de varias instancias del mismo servicio de Windows en un servidor

Puede ejecutar varias versiones del mismo servicio haciendo lo siguiente:

1) Copie el ejecutable del Servicio y config a su propia carpeta.

2) Copiar instalación.Exe a la carpeta ejecutable del servicio (de la carpeta. net framework)

3) Cree un archivo de configuración llamado Install.exe.configuración en la carpeta ejecutable del servicio con los siguientes contenidos (nombres de servicio únicos):

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="ServiceName" value="The Service Name"/>
    <add key="DisplayName" value="The Service Display Name"/>
  </appSettings>
</configuration>

4) Cree un archivo por lotes para instalar el servicio con lo siguiente contenido:

REM Install
InstallUtil.exe YourService.exe
pause

5) Mientras está allí, cree un archivo por lotes de desinstalación

REM Uninstall
InstallUtil.exe -u YourService.exe
pause

EDITAR:

Tenga en cuenta que si me perdí algo, aquí está la clase ServiceInstaller (ajuste según sea necesario):

using System.Configuration;

namespace Made4Print
{
    partial class ServiceInstaller
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;
        private System.ServiceProcess.ServiceInstaller FileProcessingServiceInstaller;
        private System.ServiceProcess.ServiceProcessInstaller FileProcessingServiceProcessInstaller;

        /// <summary> 
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Component Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.FileProcessingServiceInstaller = new System.ServiceProcess.ServiceInstaller();
            this.FileProcessingServiceProcessInstaller = new System.ServiceProcess.ServiceProcessInstaller();
            // 
            // FileProcessingServiceInstaller
            // 
            this.FileProcessingServiceInstaller.ServiceName = ServiceName;
            this.FileProcessingServiceInstaller.DisplayName = DisplayName;
            // 
            // FileProcessingServiceProcessInstaller
            // 
            this.FileProcessingServiceProcessInstaller.Account = System.ServiceProcess.ServiceAccount.LocalSystem;
            this.FileProcessingServiceProcessInstaller.Password = null;
            this.FileProcessingServiceProcessInstaller.Username = null;
            // 
            // ServiceInstaller
            // 
            this.Installers.AddRange(new System.Configuration.Install.Installer[] { this.FileProcessingServiceInstaller, this.FileProcessingServiceProcessInstaller });
        }

        #endregion

        private string ServiceName
        {
            get
            {
                return (ConfigurationManager.AppSettings["ServiceName"] == null ? "Made4PrintFileProcessingService" : ConfigurationManager.AppSettings["ServiceName"].ToString());
            }
        }

        private string DisplayName
        {
            get
            {
                return (ConfigurationManager.AppSettings["DisplayName"] == null ? "Made4Print File Processing Service" : ConfigurationManager.AppSettings["DisplayName"].ToString());
            }
        }
    }
}

  sc create [servicename] binpath= [path to your exe]

Esta solución funcionó para mí.

Vieja pregunta, lo sé, pero he tenido suerte usando la opción /servicename en InstallUtil.exe. Sin embargo, no lo veo en la ayuda incorporada.

InstallUtil.exe /servicename="My Service" MyService.exe

No estoy del todo seguro de dónde leí por primera vez sobre esto, pero no lo he visto desde entonces. YMMV.

No tuve mucha suerte con los métodos anteriores al usar nuestro software de implementación automatizada para instalar/desinstalar con frecuencia servicios de Windows lado a lado, pero finalmente se me ocurrió lo siguiente que me permite pasar un parámetro para especificar un sufijo al nombre del servicio en la línea de comandos. También permite que el diseñador funcione correctamente y podría adaptarse fácilmente para anular el nombre completo si es necesario.

public partial class ProjectInstaller : System.Configuration.Install.Installer
{
  protected override void OnBeforeInstall(IDictionary savedState)
  {
    base.OnBeforeInstall(savedState);
    SetNames();
  }

  protected override void OnBeforeUninstall(IDictionary savedState)
  {
    base.OnBeforeUninstall(savedState);
    SetNames();
  }

  private void SetNames()
  {
    this.serviceInstaller1.DisplayName = AddSuffix(this.serviceInstaller1.DisplayName);
    this.serviceInstaller1.ServiceName = AddSuffix(this.serviceInstaller1.ServiceName);
  }

  private string AddSuffix(string originalName)
  {
    if (!String.IsNullOrWhiteSpace(this.Context.Parameters["ServiceSuffix"]))
      return originalName + " - " + this.Context.Parameters["ServiceSuffix"];
    else
      return originalName;
  }
}

Con esto en mente, puedo hacer lo siguiente: Si he llamado el servicio "Awesome Service", entonces puedo instalar una versión UAT del servicio de la siguiente manera:

InstallUtil.exe /ServiceSuffix="UAT" MyService.exe

Esto creará el servicio con el nombre "Awesome Service - UAT". Hemos utilizado esto para ejecutar DEVINT, PRUEBAS y versiones de ACEPTACIÓN del mismo servicio que se ejecutan lado a lado en una sola máquina. Cada versión tiene su propio conjunto de archivos / configuraciones - no he intentado esto para instalar varios servicios apuntando al mismo conjunto de archivos.

NOTA: tienes que usar lo mismo /ServiceSuffix parámetro para desinstalar el servicio, por lo que ejecutaría lo siguiente para desinstalar:

InstallUtil.exe /u /ServiceSuffix="UAT" MyService.exe

Lo que he hecho para que esto funcione es almacenar el nombre del servicio y el nombre para mostrar en una aplicación.config para mi servicio. Luego, en mi clase de instalador, cargo la aplicación.config como un XmlDocument y use xpath para obtener los valores y aplicarlos a ServiceInstaller.ServiceName y ServiceInstaller.DisplayName, antes de llamar a InitializeComponent (). Esto asume que no estás configurando estas propiedades en InitializeComponent (), en cuyo caso, la configuración de tu archivo de configuración será ignorada. El el siguiente código es lo que estoy llamando desde mi constructor de clase installer, antes de InitializeComponent ():

       private void SetServiceName()
       {
          string configurationFilePath = Path.ChangeExtension(Assembly.GetExecutingAssembly().Location, "exe.config");
          XmlDocument doc = new XmlDocument();
          doc.Load(configurationFilePath);

          XmlNode serviceName = doc.SelectSingleNode("/xpath/to/your/@serviceName");
          XmlNode displayName = doc.SelectSingleNode("/xpath/to/your/@displayName");

          if (serviceName != null && !string.IsNullOrEmpty(serviceName.Value))
          {
              this.serviceInstaller.ServiceName = serviceName.Value;
          }

          if (displayName != null && !string.IsNullOrEmpty(displayName.Value))
          {
              this.serviceInstaller.DisplayName = displayName.Value;
          }
      }

No creo leer el archivo de configuración directamente desde ConfigurationManager.AppSettings o algo similar funcionará como cuando se ejecuta el instalador, se ejecuta en el contexto de InstallUtil.exe, no de tu servicio .exe. Es posible que pueda hacer algo con ConfigurationManager.OpenExeConfiguration, sin embargo, en mi caso, esto no funcionó ya que estaba tratando de llegar a una costumbre sección de configuración que no se cargó.

Solo para mejorar la respuesta perfecta de @chris.casa.00 este , puede considerar la siguiente función para leer desde la configuración de su aplicación:

 public void GetServiceAndDisplayName(out string serviceNameVar, out string displayNameVar)
        {
            string configurationFilePath = Path.ChangeExtension(Assembly.GetExecutingAssembly().Location, "exe.config");
            XmlDocument doc = new XmlDocument();
            doc.Load(configurationFilePath);

            XmlNode serviceName = doc.SelectSingleNode("//appSettings//add[@key='ServiceName']");
            XmlNode displayName = doc.SelectSingleNode("//appSettings//add[@key='DisplayName']");


            if (serviceName != null && (serviceName.Attributes != null && (serviceName.Attributes["value"] != null)))
            {
                serviceNameVar = serviceName.Attributes["value"].Value;
            }
            else
            {
                serviceNameVar = "Custom.Service.Name";
            }

            if (displayName != null && (displayName.Attributes != null && (displayName.Attributes["value"] != null)))
            {
                displayNameVar = displayName.Attributes["value"].Value;
            }
            else
            {
                displayNameVar = "Custom.Service.DisplayName";
            }
        }

Otra forma rápida de especificar un valor personalizado para ServiceName y DisplayName es usar parámetros de línea de comandos installutil.

1. En su clase ProjectInstaller invalida los métodos virtuales Install(IDictionary stateSaver) y Uninstall(IDictionary savedState)

   public override void Install(System.Collections.IDictionary stateSaver)
   {
       GetCustomServiceName();
       base.Install(stateSaver);
   }
   
   public override void Uninstall(System.Collections.IDictionary savedState)
   {
       GetCustomServiceName();
       base.Uninstall(savedState);
   }
   
   //Retrieve custom service name from installutil command line parameters
   private void GetCustomServiceName()
   {
       string customServiceName = Context.Parameters["servicename"];
       if (!string.IsNullOrEmpty(customServiceName))
       {
           serviceInstaller1.ServiceName = customServiceName;
           serviceInstaller1.DisplayName = customServiceName;
       }
   }
   

2. Construye tu proyecto

3. Instale el servicio con installutil agregando su nombre personalizado usando el parámetro /servicename:

   installutil.exe /servicename="CustomServiceName" "c:\pathToService\SrvcExecutable.exe"
   

Tenga en cuenta que si no especifica /servicename en la línea de comandos, el servicio se instalará con ServiceName y Valores de DisplayName especificados en ProjectInstaller properties / config

Tuve una situación similar, donde necesitaba tener un servicio anterior, y un servicio actualizado corriendo lado a lado en el mismo servidor. (Fue más que un simple cambio de base de datos, también fueron cambios de código). Así que no podía hacer lo mismo .exe dos veces. Necesitaba una nueva .exe que fue compilado con nuevas DLL pero del mismo proyecto. Simplemente cambiar el nombre del servicio y el nombre de visualización del servicio no funcionó para mí, todavía recibí el "error de servicio ya existía" que creo que es porque estoy usando un Proyecto de Implementación. Lo que finalmente funcionó para mí es que dentro de las Propiedades de mi Proyecto de implementación hay una propiedad llamada "ProductCode" que es un Guid.

Después de eso, reconstruir el proyecto de instalación a un nuevo.exe or .msi instalado correctamente.

El enfoque más simple es que se basa el nombre del servicio en el nombre dll:

string sAssPath = System.Reflection.Assembly.GetExecutingAssembly().Location;
string sAssName = System.IO.Path.GetFileNameWithoutExtension(sAssPath);
if ((this.ServiceInstaller1.ServiceName != sAssName)) {
    this.ServiceInstaller1.ServiceName = sAssName;
    this.ServiceInstaller1.DisplayName = sAssName;
}