Une façon plus facile de déboguer un service Windows

je pense aussi qu'avoir une" version " séparée pour une exécution normale et en tant que service est la voie à suivre, mais est-il vraiment nécessaire de consacrer un commutateur de ligne de commande séparé à cette fin?

ne pourriez-vous faire:

public static int Main(string[] args)
{
  if (!Environment.UserInteractive)
  {
    // Startup as service.
  }
  else
  {
    // Startup as application
  }
}

qui aurait l ' "avantage", que vous pouvez juste démarrer votre application via doubleclick (OK, si vous avez vraiment besoin de cela) et que vous pouvez juste frapper F5 dans Visual Studio (sans la nécessité de modifier les paramètres du projet pour inclure cette Option /console ).

techniquement, le Environment.UserInteractive vérifie si le drapeau WSF_VISIBLE est placé pour la station de fenêtre actuelle, mais y a-t-il une autre raison pour laquelle il retournerait false , en plus d'être exécuté comme un service (non interactif)?

quand j'ai mis en place un nouveau projet de service il ya quelques semaines, j'ai trouvé ce poste. Bien qu'il y ait beaucoup de bonnes suggestions, je n'ai toujours pas trouvé la solution que je voulais: la possibilité d'appeler les méthodes des classes de service OnStart et OnStop sans aucune modification aux classes de service.

la solution que j'ai trouvé utilise le Environment.Interactive le mode d'exécution select, comme suggéré par d'autres réponses à ce post.

static void Main()
{
    ServiceBase[] servicesToRun;
    servicesToRun = new ServiceBase[] 
    {
        new MyService()
    };
    if (Environment.UserInteractive)
    {
        RunInteractive(servicesToRun);
    }
    else
    {
        ServiceBase.Run(servicesToRun);
    }
}

le RunInteractive helper utilise la réflexion pour appeler les méthodes protégées OnStart et OnStop :

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);
}

C'est tout le code requis, mais j'ai aussi écrit walkthrough avec des explications.

ce que je fais habituellement est d'encapsuler la logique du service dans une classe séparée et de commencer que d'une classe "runner". Cette classe runner peut être le service réel ou juste une application de console. Votre solution a donc (au moins) 3 projets:

/ConsoleRunner
   /....
/ServiceRunner
   /....
/ApplicationLogic
   /....

Parfois, il est important d'analyser ce qui se passe pendant le démarrage du service. attacher au processus n'aide pas ici, parce que vous n'êtes pas assez rapide pour attacher le débogueur pendant que le service démarre.

la réponse courte est, je suis en utilisant le suivant 4 lignes de code pour faire ceci:

#if DEBUG
    base.RequestAdditionalTime(600000); // 600*1000ms = 10 minutes timeout
    Debugger.Launch(); // launch and attach debugger
#endif

ils sont insérés dans la méthode OnStart de la service comme suit:

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);
}

pour ceux qui ne l'ont pas fait avant, j'ai inclus conseils détaillés ci-dessous , parce que vous pouvez facilement obtenir coincé. Les conseils suivants se réfèrent à Windows 7x64 et Visual Studio 2010 Team Edition , mais devraient être valables pour d'autres environnements, aussi.

Important: déployer le service en " mode manuel (en utilisant l'utilitaire InstallUtil de L'invite de commande VS ou en exécutant un projet d'installateur de service que vous avez préparé). Open Visual Studio avant vous démarrez le service et chargez la solution contenant le code source du service - mettez en place des points d'arrêt supplémentaires que vous avez besoin dans Visual Studio - puis démarrez le service via le Panneau de contrôle de Service .

En raison du code Debugger.Launch , cela causera un dialogue "une exception Microsoft.NET Framework non manipulé a eu lieu dans nom de service.exe ." apparaître. Cliquez ici Oui, déboguez nom de service.exe comme le montre la capture d'écran:

ensuite, spécialement dans les fenêtres 7 UAC pourrait vous inviter à entrer des informations d'identification admin. Entrez-les et procédez avec Oui :

après cela, la fenêtre de débogueur "Just-In-Time" de Visual Studio apparaît. Il vous demande si vous voulez déboguer en utilisant le débogueur delecté. Avant de cliquer sur Oui , sélectionnez que vous ne voulez pas ouvrir une nouvelle instance (2e option) - une nouvelle instance ne serait pas utile ici, parce que le code source ne sont pas affichés. Donc vous sélectionnez L'instance Visual Studio que vous avez ouverte plus tôt à la place:

après que vous ayez cliqué sur Oui , après un certain temps Visual Studio affichera la flèche jaune à droite dans la ligne où la déclaration Debugger.Launch est et vous êtes en mesure de déboguer votre code (méthode MyInitOnStart , qui contient votre initialisation).

Pressing F5 continue l'exécution immédiatement, jusqu'à ce que le prochain point de rupture que vous avez préparé soit atteint.

Conseil: pour maintenir le service en marche, sélectionnez déboguer -> détacher tout . Cela vous permet d'exécuter un client qui communique avec le service après qu'il a démarré correctement et que vous avez terminé le débogage du code de démarrage. Si vous appuyez sur Shift + F5 (arrêt du débogage), cela mettra fin au service. Au lieu de faire cela, vous devriez utiliser le Panneau de contrôle de Service pour l'arrêter.

Note que

• si vous construisez une version, alors le code de débogage est automatiquement supprimé et le service fonctionne normalement.

• j'utilise Debugger.Launch() , qui démarre et fixe un débogueur . J'ai testé Debugger.Break() ainsi, qui n'a pas fonctionné , parce qu'il n'y a pas encore de débogueur attaché au démarrage du service (provoquant l'erreur "1067: le processus s'est terminé de manière inattendue." ).

• RequestAdditionalTime fixe un délai plus long pour le démarrage du service (il ne retarde pas le code lui-même, mais va immédiatement continuer avec la déclaration Debugger.Launch ). Sinon, le délai par défaut pour démarrer le service est trop court et le démarrage du service échoue si vous n'appelez pas base.Onstart(args) assez rapidement du débogueur. Pratiquement, un délai de 10 minutes évite que vous voyez le message le service n'a pas répondu..." immédiatement après le débogueur est commencer.

• une fois que vous vous y êtes habitué, cette méthode est très facile parce qu'elle vous demande simplement d'ajouter 4 lignes à un code de service existant, vous permettant de gagner rapidement le contrôle et de déboguer.

Ce vidéo YouTube par Fabio Scopel explique comment déboguer un service Windows tout à fait bien... la méthode réelle de le faire commence à 4: 45 dans la vidéo...

voici le code expliqué dans la vidéo... dans votre Programme.fichier cs, ajouter le contenu de la section de débogage...

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

        }
    }
}

dans votre Service1.fichier cs, ajouter la méthode OnDebug ()...

    public Service1()
    {
        InitializeComponent();
    }

    public void OnDebug()
    {
        OnStart(null);
    }

    protected override void OnStart(string[] args)
    {
        // your code to do something
    }

    protected override void OnStop()
    {
    }

mise à JOUR

Cette approche est de loin la plus facile:

http://www.codeproject.com/KB/dotnet/DebugWinServices.aspx

je laisse ma réponse originale ci-dessous pour la postérité.

mes services ont tendance à avoir une classe qui encapsule une minuterie car je veux que le service de vérifier à intervalles réguliers s'Il ya un travail pour elle faire.

nous sommes nouveaux dans la classe et appelons StartEventLoop() lors du démarrage du service. (Cette classe pourrait facilement être utilisé à partir d'une application console.)

l'effet secondaire agréable de cette conception est que les arguments avec lesquels vous configurez le minuteur peuvent être utilisés pour avoir un délai avant que le service ne commence réellement à fonctionner, de sorte que vous avez le temps d'attacher un débogueur manuellement.

p. S. comment attacher le débogueur manuellement à un processus en cours d'exécution...?

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");
    }
}

aussi j'avais l'habitude de faire ce qui suit (déjà mentionné dans les réponses précédentes mais avec les options de compilateur conditionnel [#if] pour aider à éviter qu'il ne se déclenche dans une compilation de version).

j'ai arrêté de le faire de cette façon parce que parfois nous oubliions de construire dans la version et avoir un débugger break Dans une application tournant sur une démo de client (embarrassant!).

#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
}

vous pouvez également lancer le service via l'invite de commande (sc.EXE.)

personnellement, je lancerais le code en tant que programme autonome dans la phase de débogage, et quand la plupart des bogues sont résolus, passez à running as service.

ce que j'avais l'habitude de faire était d'avoir un commutateur de ligne de commande qui démarrerait le programme soit comme un service ou comme une application régulière. Puis, dans mon IDE, je réglais le commutateur pour pouvoir passer en revue mon code.

avec certaines langues, vous pouvez en fait détecter si elle tourne dans un IDE, et effectuer ce commutateur automatiquement.

Quelle langue utilisez-vous?

je pense que cela dépend de ce que vous utilisez OS, Vista est beaucoup plus difficile à attacher aux Services, en raison de la séparation entre les sessions.

les deux options que j'ai utilisées dans le passé sont:

• utilisez GFlags (dans les outils de débogage pour Windows) pour configurer un débogueur permanent pour un processus. Cela existe dans la clé de registre" Image File Execution Options " et est incroyablement utile. Je pense que vous aurez besoin de modifier les paramètres de Service pour permettre à "Interagir avec le Bureau". Je l'utilise pour tous les types de débogage, pas seulement pour les services.
• L'autre option est de séparer un peu le code, de sorte que le service est interchangeable avec une application de démarrage. De cette façon, vous pouvez utiliser un simple drapeau de ligne de commande, et lancer comme un processus (plutôt qu'un Service), ce qui le rend beaucoup plus facile à déboguer.

Espérons que cette aide.

utilisez la bibliothèque TopShelf .

créer une application console puis configurer la configuration dans votre Main

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()
        {

        }
    }

pour déboguer votre service, cliquez sur F5 dans visual studio.

pour installer le service, tapez dans la console cmd.exe installer

vous pouvez alors démarrer et arrêter le service dans le gestionnaire de service windows.

quand j'écris un service, je mets toute la logique du service dans un projet dll et je crée deux" hôtes " qui appellent dans cette dll, l'un est un service Windows et l'autre est une application en ligne de commande.

j'utilise l'application en ligne de commande pour déboguer et j'attache le débogueur au service réel seulement pour les bogues que je ne peux pas reproduire dans l'application en ligne de commande.

je vous utilisez cette approche n'oubliez pas que vous avez à tester tout le code lors de l'exécution dans un service réel, alors que l'outil de ligne de commande est un outil de débogage agréable, c'est un environnement différent et il ne se comporte pas exactement comme un service réel.

j'aime pouvoir déboguer tous les aspects de mon service, y compris toute initialisation dans OnStart(), tout en l'exécutant avec un comportement de service complet dans le cadre du SCM... pas de "console" ou "app" de mode.

je le fais en créant un second service, dans le même projet, à utiliser pour le débogage. Le service de débogage, lorsqu'il est lancé comme d'habitude (i.e. dans le plugin services MMC), crée le processus hôte du service. Cela vous donne un processus d'attacher le débogueur même si vous n'avez pas encore commencé votre service. Après avoir attaché le débogueur au processus, démarrez votre service réel et vous pouvez le pirater n'importe où dans le cycle de vie du service, y compris OnStart().

parce qu'il nécessite une intrusion de code très minime, le service de débogage peut facilement être inclus dans votre projet de configuration de service, et est facilement retiré de votre version de production en commentant une seule ligne de code et en supprimant un installateur de projet unique.

détails:

1) en supposant que vous mettez en œuvre MyService , créez aussi MyServiceDebug . Ajouter les deux au tableau ServiceBase dans Program.cs comme suit:

    /// <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) Ajouter le service réel et le service de débogage à l'installateur de projet pour le projet de service:

les deux services (Real et debug) sont inclus lorsque vous ajoutez le extrant du projet de service au projet d'installation pour le service. Après l'installation, les deux services apparaîtront dans le service.MSC MMC plugin.

3) démarrer le service de débogage dans MMC.

4) dans Visual Studio, attachez le débogueur au processus lancé par le service de débogage.

5) démarrez le service réel et profitez du débogage.

lors du développement et du débogage d'un service Windows, je l'exécute typiquement comme une application console en ajoutant un paramètre de démarrage /console et en le vérifiant. Rend la vie beaucoup plus facile.

static void Main(string[] args) {
    if (Console.In != StreamReader.Null) {
        if (args.Length > 0 && args[0] == "/console") {
            // Start your service work.
        }
    }
}

Que Diriez-vous D'un débogueur?Pause() dans la première ligne?

pour déboguer les Services Windows je combine GFlags et A.fichier reg créé par regedit.

1. Exécuter GFlags, en spécifiant le fichier exe-nom et vsjitdebugger
2. lancez regedit et allez à l'emplacement où GFlags définit ses options
3. choisissez "clé D'exportation" dans le menu Fichier
4. enregistrez ce fichier quelque part avec le .extension reg
5. chaque fois que vous voulez déboguer le service: doubleclick sur le. fichier reg
6. si vous voulez arrêter de déboguer, double clic sur la seconde .fichier reg

ou sauvegardez les extraits suivants et remplacez le nom de service.exe avec le nom exécutable désiré.

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"

pour une programmation de routine, j'ai fait un truc très simple pour déboguer facilement mon service:

au début du service, je vérifie un paramètre de ligne de commande "/debug". Si le service est appelé avec ce paramètre, Je ne fais pas le démarrage habituel du service, mais au lieu de cela je démarre tous les écouteurs et j'affiche juste un messagebox "Debug in progress, press ok to end".

donc si mon service est commencé de la manière habituelle, il commencera comme service, si elle est démarré avec le paramètre /debug de la ligne de commande, il agira comme un programme normal.

dans VS je vais juste ajouter / déboguer comme paramètre de débogage et démarrer le programme de service directement.

de cette façon, je peux facilement Déboguer pour la plupart des petits problèmes. Bien sûr, certaines choses devront encore être déboguées en tant que service, mais pour 99% c'est suffisant.

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

j'utilise une variation sur la réponse de JOP. En utilisant les paramètres de la ligne de commande, vous pouvez définir le mode de débogage dans L'IDE avec les propriétés du projet ou via le gestionnaire de service Windows.

protected override void OnStart(string[] args)
{
  if (args.Contains<string>("DEBUG_SERVICE"))
  {
    Debugger.Break();
  }
  ...
}

C'est un peu après la question, mais peut être utile pour référence future.

si vous le pouvez, je vous conseille d'utiliser l'excellent projet TopShelf . Il rend le développement et le débogage D'un service Windows beaucoup plus facile et ajoute rend le déploiement un peu plus facile aussi.

Check it out: http://topshelf-project.com /

Pour la recherche de pannes sur les Fenêtres existantes du Service de programme, utiliser le Débogueur.Pause () " comme d'autres gars l'a suggéré.

pour le nouveau programme de service Windows, je suggérerais d'utiliser la méthode de James Michael Hare http://geekswithblogs.net/BlackRabbitCoder/archive/2011/03/01/c-toolbox-debug-able-self-installable-windows-service-template-redux.aspx

il suffit de mettre votre Debugger lunch n'importe où et d'attacher Visualstudio au démarrage

#if DEBUG
    Debugger.Launch();
#endif

vous devez également lancer VS comme administrateur et vous devez autoriser, qu'un processus peut être débogué automatiquement par un utilisateur diffrent (comme expliqué ici ):

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

utiliser Windows Service Template C # project pour créer un nouveau service app https://github.com/HarpyWar/windows-service-template

il y a le mode console/service automatiquement détecté, auto installer/désinstaller de votre service et plusieurs fonctionnalités les plus utilisées sont inclus.

Voici la méthode simple que j'ai utilisée pour tester le service, sans méthode supplémentaire de "Debug" et avec des tests intégrés VS Unit.

[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
    }
}

vous avez deux options pour faire le débogage.

1. créer un fichier journal : personnellement, je préfère un fichier journal séparé comme un fichier texte plutôt en utilisant le journal de l'application ou le journal des événements.Mais cela vous coûtera beaucoup au nom du temps, parce qu'il est encore difficile de comprendre notre où l'emplacement exact de l'erreur est
2. Convertissez l'application en application console : cela vous permettra, tous les outils de débogage que nous pouvons utiliser dans VS.

consultez CE post de blog que j'ai créé pour le sujet.

il suffit de coller

Debugger.Break();

n'importe où dans votre code.

Par Exemple,

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);
        }
    }

il va frapper Debugger.Break(); quand vous exécutez votre programme.

la meilleure option est d'utiliser le système .Diagnostics ' espace de noms.

enfermez votre code dans if else bloquer pour le mode de débogage et le mode de publication comme indiqué ci-dessous pour passer du mode de débogage au mode de publication dans 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