Manera más fácil de depurar un servicio de Windows
https://stackoverflow.com/questions/125964
-
02-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Hay una manera más fácil a paso a través del código de iniciar el servicio a través de las Ventanas Administrador de Control de Servicios y, a continuación, adjuntar el depurador para el hilo?Es un poco engorroso y me pregunto si hay un método más sencillo.
Solución
Si quiero rápidamente depurar el servicio, acabo de caer en una Debugger.Break() en allí.Cuando esa línea es alcanzado, se me cae de vuelta a VS.No te olvides de quitar esa línea cuando haya terminado.
ACTUALIZACIÓN: Como una alternativa a la #if DEBUG pragmas, también se puede utilizar Conditional("DEBUG_SERVICE") atributo.
[Conditional("DEBUG_SERVICE")]
private static void DebugMode()
{
Debugger.Break();
}
En su OnStart, acabo de llamar a este método:
public override void OnStart()
{
DebugMode();
/* ... do the rest */
}
Allí, el código sólo puede ser habilitada durante las versiones de Depuración.Mientras lo hace, podría ser útil para crear una Configuración de generación para el servicio de depuración.
Otros consejos
Yo también creo que el tener una "versión" para la ejecución normal y como un servicio es el camino a seguir, pero, ¿es realmente necesario dedicar un independiente modificador de línea de comandos para ese propósito?
No podría usted acaba de hacer:
public static int Main(string[] args)
{
if (!Environment.UserInteractive)
{
// Startup as service.
}
else
{
// Startup as application
}
}
Que tendría el "beneficio", que usted puede iniciar su aplicación a través de doubleclick (OK, si usted realmente necesita) y que sólo puede golpear F5 en Visual Studio (sin la necesidad de modificar la configuración del proyecto para incluir a los que /console Opción).
Técnicamente, el Environment.UserInteractive comprueba si el WSF_VISIBLE Bandera de la actual estación de ventana, pero, ¿hay alguna otra razón por la que sería de retorno false, que , aparte de ser que se ejecute como una (no interactivo) servicio?
Cuando configuro un nuevo proyecto de servicio hace un par de semanas me encontré con este post.Aunque existe una gran cantidad de sugerencias, yo todavía no encontrar la solución que yo quería:La posibilidad de llamar al servicio de las clases de OnStart y OnStop métodos sin ninguna modificación en el servicio de clases.
La solución que se me ocurrió utiliza el Environment.Interactive seleccione el modo de ejecución, según lo sugerido por otras respuestas a este post.
static void Main()
{
ServiceBase[] servicesToRun;
servicesToRun = new ServiceBase[]
{
new MyService()
};
if (Environment.UserInteractive)
{
RunInteractive(servicesToRun);
}
else
{
ServiceBase.Run(servicesToRun);
}
}
El RunInteractive ayudante utiliza la reflexión para llamar a la protegida OnStart y OnStop métodos:
static void RunInteractive(ServiceBase[] servicesToRun)
{
Console.WriteLine("Services running in interactive mode.");
Console.WriteLine();
MethodInfo onStartMethod = typeof(ServiceBase).GetMethod("OnStart",
BindingFlags.Instance | BindingFlags.NonPublic);
foreach (ServiceBase service in servicesToRun)
{
Console.Write("Starting {0}...", service.ServiceName);
onStartMethod.Invoke(service, new object[] { new string[] { } });
Console.Write("Started");
}
Console.WriteLine();
Console.WriteLine();
Console.WriteLine(
"Press any key to stop the services and end the process...");
Console.ReadKey();
Console.WriteLine();
MethodInfo onStopMethod = typeof(ServiceBase).GetMethod("OnStop",
BindingFlags.Instance | BindingFlags.NonPublic);
foreach (ServiceBase service in servicesToRun)
{
Console.Write("Stopping {0}...", service.ServiceName);
onStopMethod.Invoke(service, null);
Console.WriteLine("Stopped");
}
Console.WriteLine("All services stopped.");
// Keep the console alive for a second to allow the user to see the message.
Thread.Sleep(1000);
}
Este es todo el código necesario, pero también me escribió tutorial con explicaciones.
A veces es importante analizar lo que está pasando durante el inicio de la prestación del servicio. Adjuntar al proceso no ayuda aquí, porque no eres lo suficientemente rápido como para conectar el depurador mientras que el servicio se está iniciando.
La respuesta corta es, yo estoy usando el siguiente 4 líneas de código para hacer esto:
#if DEBUG
base.RequestAdditionalTime(600000); // 600*1000ms = 10 minutes timeout
Debugger.Launch(); // launch and attach debugger
#endif
Estos se insertan en el OnStart método del servicio de la siguiente manera:
protected override void OnStart(string[] args)
{
#if DEBUG
base.RequestAdditionalTime(600000); // 10 minutes timeout for startup
Debugger.Launch(); // launch and attach debugger
#endif
MyInitOnstart(); // my individual initialization code for the service
// allow the base class to perform any work it needs to do
base.OnStart(args);
}
Para aquellos que no lo ha hecho antes, he incluido detallada los siguientes consejos, porque usted puede conseguir fácilmente atrapados.Las siguientes indicaciones se refieren a Windows 7x64 y 2010 De Visual Studio Team Edition, pero debería ser válido para otros entornos, demasiado.
Importante: Implementar el servicio en el modo "manual" (mediante la InstallUtil utilidad de la VS símbolo del sistema o ejecutar un instalador de servicio del proyecto se han preparado).Abra Visual Studio antes de inicie el servicio de carga y la solución que contiene el código fuente - establecer puntos de interrupción adicionales a medida que se requiera en Visual Studio, a continuación, inicie el servicio a través de la Servicio De Panel De Control.
Debido a la Debugger.Launch código, esto va a causar un cuadro de diálogo de "Un no controlada de Microsoft .NET Framework excepción se produjo en Servicename.exe." para que aparezcan.Haga clic en 
Sí, depuración Servicename.exe como se muestra en la captura de pantalla:
Después, escpecially en Windows 7 UAC le solicitará que introduzca credenciales de administrador.Entrar en ellos y proceder con Sí:
Después de eso, el conocido Visual Studio Just-In-Time ventana del Depurador aparece.Se le pregunta si desea depurar el uso de la delected depurador. Antes de que usted haga clic en Sí, seleccione que no quieres abrir una nueva instancia (Opción 2) - una nueva instancia no sería útil aquí, ya que el código fuente no se mostrará.Así que usted seleccione la instancia de Visual Studio que hemos abierto anteriormente en su lugar:
Después de haber hecho clic Sí, después de un tiempo de Visual Studio mostrará la flecha amarilla a la derecha en la línea donde el Debugger.Launch declaración y que son capaces de depurar el código (método MyInitOnStart, que contiene la inicialización).
Pulsando F5 continúa la ejecución de inmediato, hasta el siguiente punto de interrupción que han preparado es alcanzado.
Sugerencia: Para mantener el servicio en ejecución, seleccione Debug -> Separar todos.Esto le permite ejecutar un cliente que se comunique con el servicio después de iniciado correctamente y que haya terminado de depurar el código de inicio.Si pulsa Cambio+F5 (detener depuración), esto va a terminar el servicio.En lugar de hacer esto, usted debe utilizar el Panel De Control De Servicios para detenerlo.
Nota que
Si usted construye un Liberación, a continuación, el el código de depuración se elimina automáticamente y el servicio se ejecuta normalmente.
Estoy usando
Debugger.Launch(), que se inicia y se asocia a un depurador.He probadoDebugger.Break()así, que no trabajo, porque no hay ningún depurador en la puesta en marcha del servicio (lo que provoca la "Error 1067:El proceso terminó inesperadamente.").RequestAdditionalTimeestablece un más tiempo de espera para el inicio del servicio (es no retrasar el código en sí, pero inmediatamente continuar con elDebugger.Launchla declaración).De lo contrario el tiempo de espera predeterminado para iniciar el servicio es demasiado corto y el inicio del servicio se produce un error si usted no llama abase.Onstart(args)con la suficiente rapidez desde el depurador.Prácticamente, un tiempo de espera de 10 minutos para evitar que aparezca el mensaje "el servicio no respondió..." inmediatamente después se inicia el depurador.Una vez que te acostumbras a él, este método es muy fácil ya que sólo requiere agregar 4 líneas a un servicio ya existente de código, lo que permite rápidamente para obtener el control y depuración.
Lo que suele hacer es encapsular la lógica del servicio en una clase separada y empezar a que a partir de un 'corredor' de la clase.Este corredor de la clase puede ser real o simplemente una aplicación de consola.Por lo que su solución tiene (al menos) 3 proyectos:
/ConsoleRunner
/....
/ServiceRunner
/....
/ApplicationLogic
/....
Este Vídeo de YouTube por Fabio Scopel explica cómo depurar un servicio de Windows bastante bien...el método real de hacerlo comienza a las 4:45 en el video...
Aquí está el código se explica en el video...en su Programa.cs archivo, agregar el material para la Depuración de la sección...
namespace YourNamespace
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main()
{
#if DEBUG
Service1 myService = new Service1();
myService.OnDebug();
System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);
#else
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new Service1()
};
ServiceBase.Run(ServicesToRun);
#endif
}
}
}
En su Service1.cs archivo, agregue el OnDebug() método...
public Service1()
{
InitializeComponent();
}
public void OnDebug()
{
OnStart(null);
}
protected override void OnStart(string[] args)
{
// your code to do something
}
protected override void OnStop()
{
}
Cómo funciona
Básicamente, usted tiene que crear un public void OnDebug() que llama a la OnStart(string[] args) como es protegida y no accesibles en el exterior.El void Main() el programa se añade con #if preprocesador con #DEBUG.
Visual Studio define DEBUG si el proyecto se compila en modo de Depuración.Esto permitirá la depuración de la sección(a continuación) a ejecutar cuando la condición es verdadera
Service1 myService = new Service1();
myService.OnDebug();
System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);
Y se ejecuta como una aplicación de consola, una vez que las cosas van ACEPTAR usted puede cambiar el modo de Release y el regular else la sección va a desencadenar la lógica
ACTUALIZACIÓN
Este enfoque es, por mucho, la más fácil:
http://www.codeproject.com/KB/dotnet/DebugWinServices.aspx
Os dejo mi respuesta original a continuación para la posteridad.
Mis servicios tienden a tener una clase que encapsula un Temporizador como quiero el servicio para comprobar a intervalos regulares, si existe algún trabajo para hacer.
Estamos de nuevo hasta la clase y llamar a StartEventLoop() durante el inicio del servicio.(Esta clase podría fácilmente ser utilizado desde una aplicación de consola, también.)
El efecto colateral de este diseño es que los argumentos con los que configurar el Temporizador se puede utilizar para tener un retraso antes de que el servicio empieza a funcionar realmente, así que tienes tiempo para adjuntar un depurador de forma manual.
p.s. Cómo conectar el depurador manualmente para la ejecución de un proceso...?
using System;
using System.Threading;
using System.Configuration;
public class ServiceEventHandler
{
Timer _timer;
public ServiceEventHandler()
{
// get configuration etc.
_timer = new Timer(
new TimerCallback(EventTimerCallback)
, null
, Timeout.Infinite
, Timeout.Infinite);
}
private void EventTimerCallback(object state)
{
// do something
}
public void StartEventLoop()
{
// wait a minute, then run every 30 minutes
_timer.Change(TimeSpan.Parse("00:01:00"), TimeSpan.Parse("00:30:00");
}
}
También he utilizado para hacer el siguiente (ya mencionado en anteriores respuestas, pero con el condicional compilador [#si] indicadores para ayudar a evitar que el disparo en una versión de Lanzamiento).
Dejé de hacerlo de esta manera porque a veces nos gustaría que se olvide de la Liberación y tener un depurador de descanso en una aplicación que se ejecuta en un cliente de demostración (vergonzoso!).
#if DEBUG
if (!System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
#endif
static void Main()
{
#if DEBUG
// Run as interactive exe in debug mode to allow easy
// debugging.
var service = new MyService();
service.OnStart(null);
// Sleep the main thread indefinitely while the service code
// runs in .OnStart
Thread.Sleep(Timeout.Infinite);
#else
// Run normally as service in release mode.
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]{ new MyService() };
ServiceBase.Run(ServicesToRun);
#endif
}
Usted también puede iniciar el servicio a través de la línea de comandos (sc.exe).
Personalmente, me gustaría ejecutar el código como un programa independiente en la fase de depuración, y cuando la mayoría de los errores de planchado, cambio de ejecución como servicio.
Lo que solía hacer era tener un modificador de línea de comandos que daría inicio el programa, ya sea como un servicio o como una aplicación normal.Entonces, en mi IDE me gustaría ajuste el conmutador de modo que yo pudiera paso a través de mi código.
Con algunos idiomas, en realidad se puede detectar si se está ejecutando en un IDE, y llevar a cabo este interruptor automáticamente.
¿En qué idioma estás usando?
El uso de la TopShelf biblioteca.
Crear una aplicación de consola, a continuación, configurar la instalación en su Principal
class Program
{
static void Main(string[] args)
{
HostFactory.Run(x =>
{
// setup service start and stop.
x.Service<Controller>(s =>
{
s.ConstructUsing(name => new Controller());
s.WhenStarted(controller => controller.Start());
s.WhenStopped(controller => controller.Stop());
});
// setup recovery here
x.EnableServiceRecovery(rc =>
{
rc.RestartService(delayInMinutes: 0);
rc.SetResetPeriod(days: 0);
});
x.RunAsLocalSystem();
});
}
}
public class Controller
{
public void Start()
{
}
public void Stop()
{
}
}
Para depurar el servicio, simplemente presione F5 en visual studio.
Para instalar el servicio, escriba cmd "console.exe instalar"
A continuación, puede iniciar y detener el servicio en el administrador de servicios de windows.
Yo creo que depende de lo que OS está utilizando, Vista es mucho más difícil para adjuntar a los Servicios, debido a la separación entre sesiones.
Las dos opciones que he utilizado en el pasado son:
- Uso GFlags (en las Herramientas de Depuración para Windows) para la instalación permanente de un depurador para un proceso.Esto existe en el "Archivo de Imagen de las Opciones de Ejecución" clave de registro y es increíblemente útil.Creo que voy a necesitar para ajustar la configuración del Servicio para permitir Interactuar con el Escritorio".Yo uso este para todos los tipos de depuración, no sólo de los servicios.
- La otra opción es separar el código un poco, de modo que la parte de servicio es intercambiable con una normal con la aplicación de inicio.De esa manera, usted puede utilizar un simple comando de la línea de bandera, y el lanzamiento como un proceso (en lugar de un Servicio), que hace que sea mucho más fácil de depurar.
Espero que esto ayude.
Cuando escribo un servicio que poner toda la lógica del servicio en un proyecto dll y crear dos "ejércitos" que llaman en este archivo dll, uno es un servicio de Windows y la otra es una aplicación de línea de comandos.
Yo uso la aplicación de línea de comandos para la depuración y conectar el depurador para el real servicio sólo para los errores que no se pueden reproducir en la aplicación de línea de comandos.
Yo utilice este enfoque sólo recuerde que usted tiene que probar todo el código mientras se ejecuta en un servicio real, mientras que la herramienta de línea de comandos es una buena ayuda de la depuración es un medio diferente y no se comportan exactamente como un servicio real.
Me gustaría ser capaz de depurar todos los aspectos de mi servicio, incluyendo cualquier inicialización en OnStart(), mientras que todavía se ejecuta con servicio completo de comportamiento en el marco de la SCM...no "consola" o "aplicación" de modo.
Puedo hacer esto mediante la creación de un segundo servicio, en el mismo proyecto, a utilizar para la depuración.La depuración de servicio, cuando comenzó como de costumbre (es decir,en el complemento MMC de servicios de plugin), se crea el servicio de proceso de host.Esto le proporciona un proceso para adjuntar el depurador a pesar de que usted no ha comenzado su real servicio.Después de fijar el depurador al proceso, de inicio a su real servicio y se puede romper en cualquier lugar en el ciclo de vida del servicio, incluyendo OnStart().
Porque requiere muy mínimos en el código de la intrusión, la depuración de servicio puede ser fácilmente incluido en su servicio de instalación del proyecto, y se quita fácilmente en su versión de producción por comentario de una sola línea de código y la eliminación de un único instalador del proyecto.
Detalles:
1) Suponiendo que se están implementando MyService, también crear MyServiceDebug.Añadir ambos a la ServiceBase matriz en Program.cs así:
/// <summary>
/// The main entry point for the application.
/// </summary>
static void Main()
{
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new MyService(),
new MyServiceDebug()
};
ServiceBase.Run(ServicesToRun);
}
2) Agregar el servicio real Y la depuración de servicio para el instalador del proyecto para el proyecto de servicio:
Ambos servicios (real y depuración) incluirán al agregar el servicio de resultados del proyecto para el proyecto de instalación para el servicio.Después de la instalación, tanto de servicios como aparecerá en el servicio.msc MMC plugin.
3) Iniciar la depuración de servicio en MMC.
4) En Visual Studio, adjuntar el depurador al proceso iniciado por el servicio de depuración.
5) Iniciar el servicio real y disfrutar de la depuración.
Cuando el desarrollo y depuración de un servicio de Windows que normalmente se ejecuta como una aplicación de consola mediante la adición de un /consola parámetro de inicio y comprobación de esta.Hace la vida mucho más fácil.
static void Main(string[] args) {
if (Console.In != StreamReader.Null) {
if (args.Length > 0 && args[0] == "/console") {
// Start your service work.
}
}
}
¿Y Depurador.Break() en la primera línea?
Para depurar los Servicios de Windows puedo combinar GFlags y un .reg archivo creado por regedit.
- Ejecutar GFlags, especificando el exe-nombre y vsjitdebugger
- Ejecutar regedit y vaya a la ubicación donde GFlags establece sus opciones
- Seleccione "Exportar la Clave" desde el menú del archivo
- Guardar el archivo en alguna parte con el .extensión reg
- En cualquier momento que desee depurar el servicio:haga doble clic sobre el .archivo reg
- Si desea detener la depuración, haga doble clic sobre el segundo .archivo reg
O guardar los siguientes fragmentos de código y reemplazar servicename.exe con el nombre de archivo ejecutable.
debugon.reg:
Windows Registry Editor Version 5.00 [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\servicename.exe] "GlobalFlag"="0x00000000" "Debugger"="vsjitdebugger.exe"
debugoff.reg:
Windows Registry Editor Version 5.00 [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\servicename.exe] "GlobalFlag"="0x00000000"
Para la rutina de las pequeñas cosas de programación que he hecho un truco muy simple para facilidad de depuración mi servicio:
En el inicio del servicio, puedo comprobar si un parámetro de línea de comandos "/debug".Si el servicio se llama con este parámetro, no me la costumbre de inicio del servicio, pero en lugar de arrancar todos los oyentes y solo mostrar un cuadro de mensaje "Debug en progreso, pulse aceptar para finalizar".
Así que si a mi se inicia el servicio de la forma habitual, se iniciará el servicio, si se inicia con el parámetro de línea de comandos /debug actuará como un programa normal.
En el VS, yo sólo voy a agregar /depuración como la depuración de parámetros e iniciar el programa de servicio directamente.
De esta forma, se puede fácilmente de depuración para la mayoría de las pequeñas tipo de problemas.Por supuesto, algunas cosas todavía tendrá que ser depurado como el servicio, pero para el 99% de este es lo suficientemente bueno.
#if DEBUG
System.Diagnostics.Debugger.Break();
#endif
Yo uso una variación en JOP la respuesta.El uso de parámetros de línea de comandos puede establecer el modo de depuración en el IDE con las propiedades del proyecto o a través del administrador de servicios de Windows.
protected override void OnStart(string[] args)
{
if (args.Contains<string>("DEBUG_SERVICE"))
{
Debugger.Break();
}
...
}
Para la solución de problemas en Windows existente programa de Servicio, uso del Depurador'.Break()' como otros chicos sugerido.
Para el nuevo Servicio de Windows del programa, me gustaría sugerir el uso de James Michael Liebre del método http://geekswithblogs.net/BlackRabbitCoder/archive/2011/03/01/c-toolbox-debug-able-self-installable-windows-service-template-redux.aspx
Sólo hay que poner su depurador almuerzo en cualquier lugar y adjuntar Visualstudio en el inicio
#if DEBUG
Debugger.Launch();
#endif
También usted necesita para empezar a VS como Administatrator y necesita permitir, que un proceso puede automáticamente ser depurado por un diffrent de usuario (como se explica aquí):
reg add "HKCR\AppID{E62A7A31-6025-408E-87F6-81AEB0DC9347}" /v AppIDFlags /t REG_DWORD /d 8 /f
Uso de Servicio de Windows Plantilla de proyecto de C# para crear una nueva aplicación de servicio de https://github.com/HarpyWar/windows-service-template
Hay consola/modo de servicio se detecta automáticamente, auto installer/deinstaller de su servicio y varias funciones más usadas están incluidos.
Aquí está el simple método que he utilizado para probar el servicio, sin necesidad de "Depurar" los métodos y con la integrada VS Unidad de Pruebas.
[TestMethod]
public void TestMyService()
{
MyService fs = new MyService();
var OnStart = fs.GetType().BaseType.GetMethod("OnStart", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
OnStart.Invoke(fs, new object[] { null });
}
// As an extension method
public static void Start(this ServiceBase service, List<string> parameters)
{
string[] par = parameters == null ? null : parameters.ToArray();
var OnStart = service.GetType().GetMethod("OnStart", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
OnStart.Invoke(service, new object[] { par });
}
static class Program
{
static void Main()
{
#if DEBUG
// TODO: Add code to start application here
// //If the mode is in debugging
// //create a new service instance
Service1 myService = new Service1();
// //call the start method - this will start the Timer.
myService.Start();
// //Set the Thread to sleep
Thread.Sleep(300000);
// //Call the Stop method-this will stop the Timer.
myService.Stop();
#else
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new Service1()
};
ServiceBase.Run(ServicesToRun);
#endif
}
}
Usted tiene dos opciones para hacer la depuración.
- crear un archivo de registro :Personalmente prefiero un archivo de registro independiente como archivo de texto en lugar de usar la aplicación, inicie sesión o registro de eventos.Pero esto va a costar mucho en nombre de momento, ya que todavía difícil de entender nuestro donde la exacta ubicación del error es
- Convertir la aplicación a aplicación de consola :esto le permitirá a usted todas las herramientas de depuración que podemos utilizar en VS.
Por favor consulte ESTE post en el blog que he creado para el tema.
Sólo tienes que pegar
Debugger.Break();
en cualquier lugar en el código.
Por Ejemplo ,
internal static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
private static void Main()
{
Debugger.Break();
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new Service1()
};
ServiceBase.Run(ServicesToRun);
}
}
Se golpeó Debugger.Break(); cuando ejecuta el programa.
La mejor opción es usar elSistema.Diagnóstico'espacio de nombres.
Incluya el código de if else bloque para el modo de depuración y modo de lanzamiento, como se muestra a continuación para cambiar entre la depuración y el modo de lanzamiento de visual studio,
#if DEBUG // for debug mode
**Debugger.Launch();** //debugger will hit here
foreach (var job in JobFactory.GetJobs())
{
//do something
}
#else // for release mode
**Debugger.Launch();** //debugger will hit here
// write code here to do something in Release mode.
#endif
