c# - visual - ¿Cómo depurar el método.NET Windows Service OnStart?

windows service c#

Question

Tengo un código escrito en .NET que solo falla cuando se instala como un servicio de Windows. La falla no permite que el servicio siquiera comience. No puedo entender cómo puedo entrar en el método OnStart.

Cómo: depurar las aplicaciones de servicio de Windows da una pista tentadora:

La vinculación al proceso del servicio le permite depurar la mayoría pero no todo el código del servicio; por ejemplo, debido a que el servicio ya se ha iniciado, no puede depurar el código en el método OnStart del servicio de esta manera, o el código en el método Principal que se utiliza para cargar el servicio. Una forma de evitar esto es crear un segundo servicio temporal en su aplicación de servicio que existe solo para ayudar en la depuración. Puede instalar ambos servicios y luego iniciar este servicio "ficticio" para cargar el proceso del servicio. Una vez que el servicio temporal haya comenzado el proceso, puede usar el menú Depurar en Visual Studio para adjuntarlo al proceso del servicio.

Sin embargo, no tengo claro cómo se supone que debes crear el servicio ficticio para cargar el proceso de servicio.

Answer 1

¡Funciona bien!

protected override void OnStart(string[] args)
{
    System.Diagnostics.Debugger.Launch();
}

Answer 2

Antes de entrar en el tema, uno aconseja. Utilice siempre el registro especialmente si es desarrollador del lado del servidor. Debido a que hay ciertas condiciones que no podrá producir al depurar el código en Visual Studio.

Volviendo al tema, utilizo la bandera Envoirnment.UserInteractive, esta es muy útil. Vea mi código a continuación.

public static void Main(string[] args)
{

    if (System.Environment.UserInteractive)
    {
        string parameter = string.Concat(args);

        switch (parameter)
        {
            case "--install":
                ManagedInstallerClass.InstallHelper(new string[] { Assembly.GetExecutingAssembly().Location });
                break;
            case "--uninstall":
                ManagedInstallerClass.InstallHelper(new string[] { "/u", Assembly.GetExecutingAssembly().Location });
                break;
            default:
                WindowsService service = new WindowsService();
                service.OnStart(args);
                Console.ReadKey();
                service.OnStop();
                break;
        }
    }
    else
    {
        ServiceBase.Run(new WindowsService());
    }
}

Desde Visual Studio obtendrás el flag UserInteractive para que lo ejecute como aplicación de consola. Además de eso, incluso puedes ejecutar la creación del producto haciendo doble clic en él y adjuntando el depurador si quieres probarlo.

Answer 3

Como han señalado otros, debe agregar un corte de depuración al Método OnStart:

#if DEBUG
    System.Diagnostics.Debugger.Break()
#endif

También inicie VisualStudio como administrador y permita que un proceso pueda ser depurado automáticamente por un usuario diferente (como se explica here ):

reg add "HKCR/AppID/{E62A7A31-6025-408E-87F6-81AEB0DC9347}" /v AppIDFlags /t REG_DWORD /d 8 /f

(También lo explique aquí: https://.com/a/35715389/5132456 )

Answer 4

Es posible configurar un proyecto complementario para el Servicio de Windows que se ejecuta como una aplicación de consola, pero accede a los métodos de servicio utilizando Reflection. Consulte aquí para obtener detalles y un ejemplo: http://ryan.kohn.ca/articles/how-to-debug-a-windows-service-in-csharp-using-reflection/ .

Answer 5

Intente agregar Debugger.Break dentro del método problemático. Cuando el servicio comience, se lanzará una excepción y las viudas deberían ofrecerle depuración usando Visual Studio.

Answer 6

Las opciones anteriores no parecían funcionar en Windows 8.

He agregado Thread.Sleep (15000); en mi método OnStart () y establecer un punto de interrupción en la siguiente línea del código. Esto me da 15 segundos para adjuntar depurador VS a mi proceso después de iniciar el servicio y me permitió depurar el método OnStart () muy bien.

Answer 7

Por lo general, tengo una aplicación de consola que pretende ser SCM, por ejemplo, llamadas Start, Stop, que luego puedo usar como F5 para mis principales funciones de codificación / depuración, y uso Debugger.Break para la depuración cuando el servicio se ha instalado e iniciado a través del SCM.

Para empezar, significa un poco más de trabajo, tengo una lib de clase que contiene todo el código de servicio, con una clase que expone las opciones de inicio y detención a las que pueden llamar la clase de servicio de Windows y la aplicación de consola.

Mate

Answer 8

Puede agregar una línea de código como esta:

System.Diagnostics.Debugger.Break()

que abrirá una ventana que le pedirá que elija qué depurador utilizar para depurar, por ejemplo, lo que le permite adjuntar con Visual Studio y entrar en el código.

ver:

http://msdn.microsoft.com/en-us/library/system.diagnostics.debugger.break.aspx

Answer 9

Sé que es tarde, pero así es como manejamos los servicios de depuración de Windows

Primero crea una clase que actuará como el servicio.

Agregue los métodos apropiados para iniciar, detener, pausar, etc.

Agregue un formulario de Windows al proyecto de servicio.

En el código de servicio, cree la clase de servicio creada anteriormente y realice las llamadas necesarias para iniciar y detener el servicio en la clase ServiceBase.

Abra el Program.cs y agregue lo siguiente

#if DEBUG
    [STAThread]
#endif
    static void Main()
    {
try
        {
#if DEBUG
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new DebugForm());
#else
            ServiceBase[] ServicesToRun;
            ServicesToRun = new ServiceBase[] 
        { 
            new YourWindowsService() 
        };
            ServiceBase.Run(ServicesToRun);
#endif
        }
        catch (Exception e)
        {
            logger.Error(DateTime.Now.ToString() + " - " + e.Source + " - " + e.ToString() + "/r/n------------------------------------/r/n");
        }
}

Cuando se ejecuta en modo DEBUG, se iniciará el formulario de Windows. Solo recuerde construir en modo Release cuando termine. Por supuesto, la variable de compilación condicional puede ser lo que quieras. Incluso podría crear proyectos separados, por lo que el formulario de depuración es su propio proyecto.

Espero que esto ayude

Answer 10

Si agrega Debugger.Launch () en su método OnStart y no funciona, podría tener el mismo problema que yo, es decir, la excepción estaba ocurriendo en el constructor, por lo que nunca se llamó al OnStart. (golpe de cabeza)

(Lo siento si esto debería haber sido un comentario sobre la respuesta de otra persona, pero no tengo suficiente credibilidad para hacer comentarios)

Answer 11

También puede probar el método System.Diagnostics.Debugger.Launch () . Ayuda a tomar el puntero del depurador a la ubicación especificada y luego puede depurar el código.

Antes de este paso , instale su service.exe utilizando la línea de comandos del símbolo del sistema de Visual Studio - installutil projectservice.exe

Luego, inicie su servicio desde el Panel de control -> Herramientas administrativas -> Administración de equipos -> Servicio y aplicación -> Servicios -> Su nombre de servicio

Answer 12

Tengo una forma interesante de hacerlo. Agrego otra configuración llamada DebugNoService.

  <PropertyGroup Condition=" ''$(Configuration)|$(Platform)'' == ''DebugNoService|AnyCPU'' ">
    <OutputPath>./</OutputPath>
    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
    <BaseAddress>285212672</BaseAddress>
    <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
    <ConfigurationOverrideFile>
    </ConfigurationOverrideFile>
    <DefineConstants>DEBUG;TRACE;DEBUGNOSERVICE</DefineConstants>
    <DocumentationFile>
    </DocumentationFile>
    <DebugSymbols>true</DebugSymbols>
    <FileAlignment>4096</FileAlignment>
    <NoStdLib>false</NoStdLib>
    <NoWarn>
    </NoWarn>
    <Optimize>false</Optimize>
    <RegisterForComInterop>false</RegisterForComInterop>
    <RemoveIntegerChecks>false</RemoveIntegerChecks>
    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
    <WarningLevel>4</WarningLevel>
    <DebugType>full</DebugType>
    <ErrorReport>prompt</ErrorReport>
    <UseVSHostingProcess>false</UseVSHostingProcess>
  </PropertyGroup>

Uso la directiva #if. ProjectInstaller.cs

#if !DEBUGNOSERVICE    
   static void Main()
   {
      System.ServiceProcess.ServiceBase[] ServicesToRun;
      .....
   }
#endif

Agrego un formulario de Windows y también envuelvo el formulario de Windows en

#if DEBUGNOSERVICE
...
static void Main() 
{
    Form     form;

    Application.EnableVisualStyles();
    Application.DoEvents();

    form = new <the name of the form>();

    Application.Run(form);
}
...
#endif

dependiendo de la configuración seleccionada, el código se ejecuta como una aplicación de formulario de Windows que se puede depurar fácilmente o como un servicio.

Parece mucho trabajo pero siempre ha funcionado y hace que depurar el código sea muy fácil. Puede agregar todo tipo de resultados al formulario para que pueda verlo funcionar.

Answer 13

Tiendo a agregar un método como este:

    [Conditional("DEBUG")]
    private void AttachDebugger()
    {
        Debugger.Break();
    }

solo se invocará en las compilaciones de Debug de su proyecto y se pausará la ejecución y le permitirá adjuntar el depurador.

Answer 14

Una cosa que podría hacer como una solución temporal es iniciar el depurador como la primera línea de código en OnStart

System.Diagnostics.Debugger.Launch()

Esto le solicitará el depurador que le gustaría usar. Simplemente tenga la solución ya abierta en Visual Studio y elija esa instancia de la lista.

Answer 15

Una vez que tiene un servicio que está instalado usando installutil.exe , puede alterar los Start Parameters para saltar al depurador si el servicio se inicia:

Cuando inicie manualmente el servicio con el parámetro -debugWithVisualStudio (o simplemente -d ), detectará automáticamente el proyecto correcto y activará el depurador interactivo en Visual Studio:

Para admitir esta funcionalidad, cambie la función OnStart() :

/// <summary>
///     Executed when the service is started.
/// </summary>
/// <param name="args">Command line arguments.</param>
protected override void OnStart(string[] args)
{
    try
    {
        //How to debug when running a Windows Service:
        // 1. Right click on the service name in Windows Service Manager.
        // 2. Select "Properties".
        // 3. In "Start Parameters", enter "-d" (or "-debugWithVisualStudio").
        // 4. Now, when you start the service, it will fire up Visual Studio 2012 and break on the line below.
        // 5. Make sure you have UAC (User Access Control) turned off, and have Administrator privileges.
#if DEBUG
        if (((ICollection<string>)args).Contains("-d")
            || ((ICollection<string>)args).Contains("-debugWithVisualStudio"))
        {
            Debugger.Launch(); // Launches VS2012 debugger.
        }
#endif
        ShellStart(args);
        base.OnStart(args);
    }
    catch (Exception ex)
    {
        // Log exception here.
    }
}

(opcional) Si desea restringir a la línea exacta de código donde el servicio arroja un error, active las excepciones desde el menú DEBUG .. Exceptions Visual Studio DEBUG .. Exceptions . Cuando continúe depurando, se romperá en la línea exacta que arroja la excepción.

Answer 16

Use el siguiente código en el método Service OnStart:

System.Diagnostics.Debugger.Launch();

Elija la opción de Visual Studio desde el mensaje emergente. Recuerde ejecutar Visual Studio como administrador.

Nota: Para usarlo solo en el modo de depuración, #si se puede usar la directiva del compilador DEBUG, como se muestra a continuación. Esto evitará errores accidentales o depuración en el modo de lanzamiento en el servidor de producción.

#if DEBUG
    System.Diagnostics.Debugger.Launch();
#endif