Einfacher kann ein Windows-Dienst debuggen

https://stackoverflow.com/questions/125964

02-07-2019
|

Frage

Gibt es einen einfacheren Weg durch den Code zu Schritt als den Dienst über die Windows Service Control Manager zu starten und dann den Debugger auf das Gewinde angebracht? Es ist eine Art umständlich und ich frage mich, ob es ein einfacherer Ansatz ist.

Lösung

Wenn ich den Dienst schnell zu debuggen, lasse ich nur in einem Debugger.Break() drin. Wenn diese Zeile erreicht ist, wird es mir zu VS. zurückfallen Vergessen Sie nicht, diese Linie zu entfernen, wenn Sie fertig sind.

UPDATE:. Als Alternative Pragmas #if DEBUG, können Sie auch Conditional("DEBUG_SERVICE") Attribut

[Conditional("DEBUG_SERVICE")]
private static void DebugMode()
{
    Debugger.Break();
}

Auf dem OnStart, rufen Sie diese Methode:

public override void OnStart()
{
     DebugMode();
     /* ... do the rest */
}

Es wird der Code nur während Debug baut aktiviert werden. Während Ihr es, könnte es sinnvoll sein, eine separate Build-Konfiguration für den Dienst Debuggen zu erstellen.

Andere Tipps

Ich denke, auch eine eigene „Version“ für die normale Ausführung und als Dienstleistung aufweist, ist der Weg zu gehen, aber es ist wirklich einen separaten Befehlszeilenschalter zu diesem Zweck widmen erforderlich?

Könnten Sie nicht einfach tun:

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

Das würde den „Nutzen“ haben, dass Sie nur Ihre App über einen Doppelklick starten (OK, wenn Sie wirklich brauchen, dass) und dass Sie einfach auf F5 in Visual Studio (ohne die Notwendigkeit die Projekteinstellungen zu ändern, dass /console Option enthalten).

Technisch die Environment.UserInteractive überprüft, ob der WSF_VISIBLE Flag für die aktuelle Fenster Station eingestellt ist, aber gibt es einen anderen Grund, wo es false zurückkehren würde, abgesehen von als (nicht-interaktivem) Dienst ausgeführt werden?

Wenn ich ein neues Service-Projekt vor ein paar Wochen aufgebaut fand ich diesen Beitrag. Zwar gibt es viele gute Vorschläge sind, ich habe immer noch nicht die Lösung finden wollte ich. Die Möglichkeit, die Serviceklassen OnStart und OnStop Methoden ohne Änderungen an den Serviceklassen zu nennen

Die Lösung kam ich mit verwendet dem Environment.Interactive den Select-Fahrmodus, wie von anderen Antworten zu diesem Beitrag vorgeschlagen.

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

Der RunInteractive Helfer verwendet Reflektion, um die geschützten OnStart und OnStop Methoden aufrufen:

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

Dies ist der gesamte Code erforderlich, aber ich schrieb auch Durchlauf mit Erklärungen.

Manchmal ist es wichtig, zu analysieren, was auf geht beim Start des Service. Anbau an den Prozess hier nicht helfen, weil Sie nicht schnell genug sind, um die Debugger zu befestigen, während der Dienst ist starten.

Die kurze Antwort ist, ich bin mit den folgenden 4 Zeilen Code , dies zu tun:

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

Diese werden in die OnStart Verfahren des Dienstes wie folgt eingefügt:

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

Für diejenigen, die es vorher nicht getan, ich habe enthalten detaillierte Hinweise unter , da Sie leicht stecken bleiben können. Die folgenden Hinweise beziehen sich auf Windows-7x64 und Visual Studio 2010 Team Edition , sollte aber für andere Umgebungen, auch gültig sein.

Wichtig: Stellen Sie den Service in "manuelle" Modus (entweder mit dem InstallUtil Dienstprogramm von der VS-Eingabeaufforderung oder ein Service Installer-Projekt laufen Sie vorbereitet haben). Öffnen Sie Visual Studio vor Sie den Dienst starten und die Lösung laden enthält den Quellcode des Service - eingerichtet zusätzliche Haltepunkte, wie Sie sie in Visual Studio benötigen - dann den Dienst über die Service Systemsteuerung starten.

Aufgrund der Debugger.Launch Code, dies führt dazu, dass ein Dialog "eine nicht behandelte Microsoft .NET Framework-Ausnahme aufgetreten in Servicename.exe ." erscheinen. Klicken Sie auf Ja, debug Servicename.exe , wie im Screenshot gezeigt:
FrameworkException

Danach escpecially in Windows 7 UAC könnte fordert Sie Admin-Anmeldeinformationen einzugeben. Geben Sie sie und fahren Sie mit Ja :

UACPrompt

Danach wird das bekannte Visual Studio Just-In-Time-Debugger-Fenster erscheint. Sie gefragt, ob Sie mit dem delected Debugger debuggen. Bevor Sie auf Ja , wählen, dass Sie nicht will, eine neue Instanz öffnen (zweite Option) - eine neue Instanz wäre nicht hilfreich hier wäre, weil der Quellcode nicht angezeigt werden. So wählen Sie die Visual Studio-Instanz zuvor stattdessen geöffnet haben: VSDebuggerPrompt

Nachdem Sie geklickt haben, Ja , nach einer Weile Visual Studio des gelben Pfeil rechts in der Zeile zeigen, wo die Debugger.Launch Aussage ist, und Sie sind in der Lage, Ihren Code zu debuggen (Methode MyInitOnStart, die Ihre Initialisierung enthält). VSDebuggerBreakpoint

Mit F5 setzt die Ausführung sofort, , bis der nächste Haltepunkt Sie vorbereitet haben, erreicht wird.

Hinweis: Um den Dienst am Laufen zu halten, wählen Sie Debug -> alle abnehmen . Auf diese Weise können Sie einen Client-Kommunikation mit dem Dienst ausgeführt werden soll, nachdem er gestartet richtig und Sie das Debuggen des Startcode beendet. Wenn Sie die Taste Umschalttaste + F5 (Stop Debugging), wird dies den Dienst beenden. Statt dies zu tun, sollten Sie die Service Control Panel um es zu stoppen.

Hinweis , dass

Wenn Sie bauen ein Mitteilung, und dann die Debug-Code wird automatisch entfernt und der Service läuft normal weiter.
Ich bin mit Debugger.Launch() , die startet und fügt einen Debugger . Ich habe getestet Debugger.Break() als auch, was nicht funktioniert , weil es keinen Debugger beim Starten des Dienstes noch angebracht ist (was die . "Fehler 1067:. Der Prozess wurde unerwartet beendet" )
RequestAdditionalTime setzt ein längeres Timeout für die Inbetriebnahme des Service (es ist nicht Verzögerung des Code selbst, sondern wird sofort weiterhin mit der Debugger.Launch Anweisung). Andernfalls wird das Standard-Timeout für den Dienst starten zu kurz ist und nicht den Dienst starten, wenn Sie nicht schnell genug nennen base.Onstart(args) vom Debugger. Praktisch vermeidet ein Timeout von 10 Minuten, dass Sie die Meldung " der Dienst reagierte nicht ..." unmittelbar nach dem Debugger gestartet wird.
Wenn Sie sich daran gewöhnen, ist diese Methode sehr einfach, weil es erfordert, dass Sie nur auf hinzufügen 4 Zeilen zu einem bestehenden Service-Code, so dass Sie schnell die Kontrolle und debuggen zu gewinnen.

Was ich in der Regel tut, ist die Logik des Dienstes in einer separaten Klasse kapselt und beginnen, dass von einer ‚Läufer‘ Klasse. Diese Läufer-Klasse kann der tatsächliche Service oder einfach nur eine Konsolenanwendung. So Ihre Lösung hat (mindestens) 3 Projekte:

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

Die YouTube-Video von Fabio Scopel erläutert, wie ein Windows-Dienst debuggen ganz gut ... die eigentliche Methode, es zu tun, um 4:45 im Video startet ...

Hier ist der Code im Video erklärt ... in Ihrer Program.cs Datei, die Sachen für den Debug-Abschnitt hinzufügen ...

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

        }
    }
}

In Ihrer Service1.cs Datei die OnDebug () -Methode ...

    public Service1()
    {
        InitializeComponent();
    }

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

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

    protected override void OnStop()
    {
    }

Wie es funktioniert

Im Grunde müssen Sie eine public void OnDebug() erstellen, die die OnStart(string[] args) ruft, wie es geschützt ist und nicht außen zugänglich. Das void Main() Programm wird mit #if Präprozessor mit #DEBUG hinzugefügt.

Visual Studio definiert DEBUG wenn Projekt in Debug mode.This kompiliert wird, wird dem Debug-Abschnitt (unten) erlaubt auszuführen, wenn die Bedingung erfüllt ist

Service1 myService = new Service1();
myService.OnDebug();
System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);

Und es wird wie eine Konsole-Anwendung ausführen, sobald sich die Dinge in Ordnung gehen Sie den Modus Release ändern kann und die regelmäßige else Abschnitt wird die Logik auslösen

UPDATE

Dieser Ansatz ist bei weitem der einfachste:

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

Ich lasse meine ursprüngliche Antwort unten für die Nachwelt.

Meine Dienste sind in der Regel um eine Klasse haben, die einen Timer verkapselt, wie ich den Service möchte in regelmäßigen Abständen überprüfen, ob es eine Arbeit für sie tun.

Wir neu die Klasse und rufen StartEventLoop () während der Service Inbetriebnahme. (Diese Klasse leicht von einer Konsolenanwendung zu verwendet werden könnte.)

Der nette Nebeneffekt dieser Konstruktion ist, dass die Argumente, mit denen Sie die Timer einrichten kann eine Verzögerung haben verwendet werden, bevor der Dienst tatsächlich zu arbeiten beginnt, so dass Sie Zeit haben, manuell einen Debugger zu befestigen.

P. S. Wie den Debugger manuell an einen laufenden Prozess anhängen ...

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

Auch habe ich folgende zu tun (in früheren Antworten bereits erwähnt, aber mit dem bedingten Compiler [# if] flags es zu vermeiden helfen in einem Releasebuild Brennen).

Ich hörte es auf diese Art und Weise zu tun, weil manchmal würden vergessen, dass wir in Release und haben eine Debugger Pause in einer App laufen auf einer Client-Demo (embarrasing!).

zu bauen

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

Sie können den Dienst auch über die Eingabeaufforderung starten (sc.exe).

Ich persönlich würde den Code als Stand-alone-Programm in der Debug-Phase ausgeführt werden, und wenn die meisten Bugs ausgebügelt, ändert als Dienst ausgeführt wird.

Was habe ich zu tun war, eine Befehlszeilenoption zu haben, die das Programm entweder als Dienst oder als regelmäßiger Anwendung starten würde. Dann in meiner IDE würde ich den Schalter so eingestellt, dass ich durch meinen Code Schritt könnte.

Bei manchen Sprachen kann man tatsächlich erkennen, ob es in einer IDE läuft, und führen Sie diesen Schalter automatisch.

In welcher Sprache werden Sie mit?

Mit dem Topshelf Bibliothek.

Erstellen Sie eine Konsole-Anwendung dann in Ihrem Haupt konfiguriert Setup

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

        }
    }

Ihr Dienst zu debuggen, drücken Sie einfach F5 in Visual Studio.

So installieren Sie Service, geben Sie cmd "console.exe install"

Sie können dann starten und Service in den Windows-Service-Managern beenden.

Ich denke, es hängt davon ab, welches OS Sie verwenden, Vista ist viel schwieriger zu Dienstleistungen zu befestigen, aufgrund der Trennung zwischen den Sitzungen.

Die beiden Optionen, die ich in der Vergangenheit verwendet haben, sind:

Verwenden Sie GFlags (in den Debugging Tools für Windows) ein permanentes Debugger für einen Prozess einzurichten. Diese besteht in dem „Image File Execution Options“ Registrierungsschlüssel und ist unglaublich nützlich. Ich denke, Sie brauchen, um die Service-Einstellungen optimieren „Interact mit Desktop“ zu ermöglichen. Ich benutze dies für alle Arten von Debugging, nicht nur Dienstleistungen.
Die andere Möglichkeit ist, den Code ein bisschen zu trennen, so dass der Serviceteil mit einem normalen App Start Wechselfußbettsohle ist. Auf diese Weise können Sie einen einfachen Kommandozeilen-Flag verwenden, und starten Sie als Prozess (eher als ein Service), die es viel einfacher zu debuggen macht.

Hope, das hilft.

Wenn ich einen Dienst schreibe ich die alle Service-Logik in einem DLL-Projekt setzen und erstellen Sie zwei „hosts“, die in dieser DLL aufrufen, ist ein Windows-Dienst und der andere ist ein Kommandozeilen-Anwendung.

Ich benutze die Kommandozeilen-Anwendung für das Debuggen und befestigen Sie den Debugger an den wirklichen Dienst nur für Fehler kann ich nicht in der Kommandozeilen-Anwendung reproduzieren.

Ich benutzen Sie diesen Ansatz nur daran erinnern, dass Sie alle den Code zu testen, während in einem echten Dienst ausgeführt wird, während das Kommandozeilen-Tool eine nette Debugging-Hilfe ist es eine andere Umgebung ist und es verhält sich nicht genau wie ein echter Service .

Ich mag jeden Aspekt meines Dienstes debuggen zu können, einschließlich der Initialisierung in OnStart (), während sie noch mit Full-Service-Verhalten im Rahmen des SCM ... keine „Konsole“ oder „app“ Modus ausführen .

Ich tue dies durch einen zweiten Dienst, im selben Projekt zu schaffen, für die Fehlersuche zu verwenden. Der Debug-Dienst, wenn wie üblich (das heißt in der Dienste-Plugin) gestartet wird, erstellt den Dienst Host-Prozess. Das gibt Ihnen einen Prozess die Debugger selbst zu befestigen, obwohl Sie Ihren wirklichen Dienst noch nicht begonnen. Nach dem Debugger an den Prozess Befestigung, starten Sie Ihren echten Service und Sie können im Service-Lebenszyklus, einschließlich OnStart ().

hinein überall brechen

Weil es sehr wenig Code Intrusion erfordert, kann der Debug-Service leicht in Ihrem Service Setup-Projekt aufgenommen werden, und einfach von Ihrer Produktions-Release entfernt wird durch Kommentierung eine einzige Zeile Code und einen einzelnes Projekt Installer zu löschen.

Details:

1) Angenommen, Sie MyService implementieren, schaffen auch MyServiceDebug. In sowohl den ServiceBase Array in Program.cs etwa so:

    /// <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) Fügen Sie den echten Service und den Debug-Dienst für das Projekt Installationsprogramm für das Service-Projekt:

eingeben Bild Beschreibung hier

Beiden Dienste (real und debug) enthalten werden, wenn Sie die Service-Projekt Ausgabe an das Setup-Projekt für den Dienst hinzuzufügen. Nach der Installation werden beiden Dienste im service.msc MMC-Plugin angezeigt werden.

3) Starten Sie den Debug-Dienst in der MMC.

4) In Visual Studio, befestigen Sie den Debugger an den Prozess durch den Debug-Dienst gestartet wird.

5) Starten Sie den echten Service und genießen Sie das Debuggen.

Bei der Entwicklung und Debuggen eines Windows-Dienst ich es in der Regel als Konsolenanwendung ausgeführt durch Hinzufügen eines / console Startparameter und diese zu prüfen. Das macht das Leben viel einfacher.

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

Wie wäre es Debugger.Break () in der ersten Zeile?

Windows Services debuggen ich GFlags und eine REG-Datei erstellt von regedit kombinieren.

Ausführen GFlags unter Angabe der exe-Namen und vsjitdebugger
Führen Sie regedit und gehen Sie zu der Stelle, wo GFlags seine Optionen setzt
Wählen Sie "Export Key" aus dem Datei-Menü
Speichern Sie die Datei irgendwo mit der Erweiterung von REGEN
Immer, wenn Sie den Dienst debuggen: Doppelklick auf die REG-Datei
Wenn Sie auf der zweiten REG-Datei Debuggen, doppelklicken Sie stoppen

oder die folgenden Schnipsel speichern und servicename.exe mit der gewünschten Namen der ausführbaren Datei ersetzen.

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"

Für die Routineklein Sachen Programmierung Ich habe einen sehr einfachen Trick getan leicht meinen Dienst zu debuggen:

Beim Start des Dienstes, überprüfe ich für einen Kommandozeilenparameter „/ debug“. Wenn der Dienst mit diesem Parameter aufgerufen wird, ich den üblichen Dienststart nicht tun, sondern alle Zuhörer beginnt und nur einen messagebox „Debug im Gang ist, drücken Sie OK beenden“ angezeigt werden soll.

Also, wenn mein Dienst die übliche Art und Weise gestartet wird, wird es als Dienst zu starten, wenn es mit dem Kommandozeilenparameter / debug gestartet wird es wie ein normales Programm handeln wird.

In VS werde ich nur hinzufügen / debug als Debug-Parameter und starten Sie das Service-Programm direkt.

So kann ich einfach für die meisten kleinen Art Probleme debuggen können. Natürlich noch einige Sachen als Service werden müssen debuggt, aber für 99% ist das gut genug.

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

Ich verwende eine Variation auf JOP Antwort. Befehlszeile Parameter Sie den Debug-Modus in den IDE mit Projekteigenschaften oder über die Windows-Service-Manager eingestellt werden.

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

Für die Fehlersuche auf bestehenden Windows-Service-Programm, verwenden Sie 'Debugger.Break ()' als andere Jungs vorgeschlagen.

Für neues Windows-Service-Programm, würde ich vorschlagen, James Michael Hare Methode mit http://geekswithblogs.net/BlackRabbitCoder/archive/2011/03/01/c-toolbox-debug-able-self-installable-windows- Service-template-redux.aspx

Sie Ihre Debugger Mittagessen setzen überall und befestigen Visual Studio beim Start

#if DEBUG
    Debugger.Launch();
#endif

Darüber hinaus müssen Sie VS als Administatrator starten und Sie müssen zulassen, dass ein Prozess automatisch von einem diffrent Benutzer debuggt werden kann (wie erklärt hier ):

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

Verwenden Sie Windows Service Vorlage C # Projekt einen neuen Service App erstellen https://github.com/ HarpyWar / windows-service-Vorlage

Es gibt Konsole / Service-Modus automatisch erkannt, Auto-Installer / Deinstaller Ihren Service und mehr am häufigsten verwendeten Funktionen sind enthalten.

Hier ist die einfache Methode, die ich verwenden, um den Service zu testen, ohne zusätzliche „Debug“ Methoden und mit integrierten VS-Unit-Tests.

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

Sie haben zwei Möglichkeiten, die das Debuggen zu tun.

eine Protokolldatei erstellen: Persönlich bevorzuge ich eine separate Protokolldatei wie Textdatei und nicht das Anwendungsprotokoll oder Ereignis mit log.But diese werden Sie im Namen der Zeit eine Menge Geld kosten, weil es ist immer noch schwer, unsere wo die genauen Fehler auf Figur Lage ist
Konvertieren Sie die Anwendung Anwendung auf die Konsole. Dies ermöglicht es Ihnen, alle Debugging-Tools, die wir in VS verwenden können,

Bitte lesen THIS Blog-Post, die ich erstellt für das Thema.

Fügen Sie einfach

Debugger.Break();

, wo jeder in Sie Code.

Beispiel:

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

Es wird getroffen Debugger.Break();, wenn Sie Ihr Programm ausführen.

Die beste Möglichkeit ist, die verwenden ' System.Diagnostics ' Namespace.

Legen Sie den Code in wenn auch Block für die Debug-Modus und Freigabemodus, wie unten gezeigt zwischen Debug- und Release-Modus in Visual Studio zu wechseln,

#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

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow