Wie debugge ich Windows-Dienste in Visual Studio?

Ist es möglich, die Windows-Dienste in Visual Studio zu debuggen?

Ich habe Code wie verwendet

System.Diagnostics.Debugger.Break();

aber es gibt einige Codefehler wie:

Ich habe zwei Ereignisfehler erhalten: eventID 4096 VsJITDebugger und "Der Dienst hat nicht rechtzeitig auf die Start- oder Steuerungsanforderung reagiert."

Verwenden Sie den folgenden Code in der Servicemethode OnStart:

System.Diagnostics.Debugger.Launch();

Wählen Sie die Option Visual Studio aus der Popup-Nachricht.

Hinweis: Um es nur im Debug-Modus #if DEBUGzu verwenden, kann eine Compiler-Direktive wie folgt verwendet werden. Dies verhindert ein versehentliches oder Debuggen im Release-Modus auf einem Produktionsserver.

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

Sie können dies auch versuchen.

1. Erstellen Sie Ihren Windows-Dienst und installieren und starten Sie…. Das heißt, Windows-Dienste müssen auf Ihrem System ausgeführt werden.
2. Gehen Sie während der Ausführung Ihres Dienstes zum Menü Debug und klicken Sie auf Prozess anhängen (oder Prozess in altem Visual Studio).
3. Suchen Sie Ihren laufenden Dienst und stellen Sie sicher, dass der Prozess "Von allen Benutzern anzeigen" und " Prozesse in allen Sitzungen anzeigen" ausgewählt ist. Wenn nicht, wählen Sie ihn aus.

4. Klicken Sie auf die Schaltfläche Anhängen
5. Klicken Sie auf OK
6. Klicken Sie auf Schließen
7. Setzen Sie einen Haltepunkt an Ihrem gewünschten Ort und warten Sie auf die Ausführung. Es wird automatisch debuggt, wenn Ihr Code diesen Punkt erreicht.
8. Denken Sie daran, setzen Sie Ihren Haltepunkt an eine erreichbare Stelle , wenn er onStart () ist, und stoppen Sie den Dienst und starten Sie ihn erneut

(Nach langem googeln fand ich dies unter "Debuggen der Windows-Dienste in Visual Studio".)

Sie sollten den gesamten Code trennen , die wird tun Sachen aus dem Service - Projekt in ein separates Projekt, und dann eine Testanwendung, dass Sie normalerweise laufen und debuggen können.

Das Serviceprojekt wäre nur die Shell, die zur Implementierung des Serviceteils benötigt wird.

Entweder das, wie von Lasse V. Karlsen vorgeschlagen, oder Sie richten eine Schleife in Ihrem Dienst ein, die darauf wartet, dass ein Debugger angehängt wird. Das einfachste ist

while (!Debugger.IsAttached)
{
    Thread.Sleep(1000);
}

... continue with code

Auf diese Weise können Sie den Dienst starten und in Visual Studio "An Prozess anhängen ..." auswählen und an Ihren Dienst anhängen, um dann die normale Ausführung fortzusetzen.

Angesichts ServiceBase.OnStartder protectedSichtbarkeit bin ich den Reflexionsweg gegangen, um das Debuggen zu erreichen.

private static void Main(string[] args)
{
    var serviceBases = new ServiceBase[] {new Service() /* ... */ };

#if DEBUG
    if (Environment.UserInteractive)
    {
        const BindingFlags bindingFlags =
            BindingFlags.Instance | BindingFlags.NonPublic;

        foreach (var serviceBase in serviceBases)
        {
            var serviceType = serviceBase.GetType();
            var methodInfo = serviceType.GetMethod("OnStart", bindingFlags);

            new Thread(service => methodInfo.Invoke(service, new object[] {args})).Start(serviceBase);
        }

        return;
    }
#endif

    ServiceBase.Run(serviceBases);
}

Beachten Sie, dass dies Threadstandardmäßig ein Vordergrund-Thread ist. returnWenn Mainder Faux-Service-Thread ausgeführt wird, wird der Vorgang nicht beendet.

In einem Microsoft-Artikel wird erläutert, wie Sie hier einen Windows-Dienst debuggen und welchen Teil jeder übersehen kann, wenn er ihn durch Anhängen an einen Prozess debuggt.

Unten ist mein Arbeitscode. Ich habe den von Microsoft vorgeschlagenen Ansatz verfolgt.

Fügen Sie diesen Code hinzu zu program.cs:

static void Main(string[] args)
{
    // 'If' block will execute when launched through Visual Studio
    if (Environment.UserInteractive)
    {
        ServiceMonitor serviceRequest = new ServiceMonitor();
        serviceRequest.TestOnStartAndOnStop(args);
    }
    else // This block will execute when code is compiled as a Windows application
    {
        ServiceBase[] ServicesToRun;
        ServicesToRun = new ServiceBase[]
        {
            new ServiceMonitor()
        };
        ServiceBase.Run(ServicesToRun);
    }
}

Fügen Sie diesen Code der ServiceMonitor-Klasse hinzu.

internal void TestOnStartAndOnStop(string[] args)
{
    this.OnStart(args);
    Console.ReadLine();
    this.OnStop();
}

Gehen Sie nun zu Projekteigenschaften , wählen Sie die Registerkarte "Anwendung" und wählen Sie beim Debuggen den Ausgabetyp als "Konsolenanwendung" oder nach dem Debuggen "Windows-Anwendung" aus, kompilieren Sie Ihren Dienst neu und installieren Sie ihn.

Sie können eine Konsolenanwendung erstellen. Ich benutze diese mainFunktion:

    static void Main(string[] args)
    {
        ImportFileService ws = new ImportFileService();
        ws.OnStart(args);
        while (true)
        {
            ConsoleKeyInfo key = System.Console.ReadKey();
            if (key.Key == ConsoleKey.Escape)
                break;
        }
        ws.OnStop();
    }

Meine ImportFileServiceKlasse ist genau die gleiche wie in der Anwendung meines Windows-Dienstes, mit Ausnahme von heiritant ( ServiceBase).

Sie können auch System.Diagnostics.Debugger.Launch () ausprobieren. Methode . Es hilft dabei, den Debugger-Zeiger auf den angegebenen Speicherort zu bringen, und Sie können dann Ihren Code debuggen.

Vor diesem Schritt installieren Sie bitte Ihre service.exe über die Befehlszeile der Visual Studio-Eingabeaufforderung - installutil projectservice.exe

Starten Sie dann Ihren Dienst über die Systemsteuerung -> Verwaltung -> Computerverwaltung -> Dienst und Anwendung -> Dienste -> Ihr Dienstname

Ich habe diesen Code gerade zu meiner Serviceklasse hinzugefügt, damit ich OnStart indirekt aufrufen kann, ähnlich wie bei OnStop.

    public void MyOnStart(string[] args)
    {
        OnStart(args);
    }

Ich verwende den /ConsoleParameter im Visual Studio-Projekt Debug → Startoptionen → Befehlszeilenargumente :

public static class Program
{
    [STAThread]
    public static void Main(string[] args)
    {
         var runMode = args.Contains(@"/Console")
             ? WindowsService.RunMode.Console
             : WindowsService.RunMode.WindowsService;
         new WinodwsService().Run(runMode);
    }
}


public class WindowsService : ServiceBase
{
    public enum RunMode
    {
        Console,
        WindowsService
    }

    public void Run(RunMode runMode)
    {
        if (runMode.Equals(RunMode.Console))
        {
            this.StartService();
            Console.WriteLine("Press <ENTER> to stop service...");
            Console.ReadLine();

            this.StopService();
            Console.WriteLine("Press <ENTER> to exit.");
            Console.ReadLine();
        }
        else if (runMode.Equals(RunMode.WindowsService))
        {
            ServiceBase.Run(new[] { this });
        }
    }

    protected override void OnStart(string[] args)
    {
        StartService(args);
    }

    protected override void OnStop()
    {
        StopService();
    }

    /// <summary>
    /// Logic to Start Service
    /// Public accessibility for running as a console application in Visual Studio debugging experience
    /// </summary>
    public virtual void StartService(params string[] args){ ... }

    /// <summary>
    /// Logic to Stop Service
    /// Public accessibility for running as a console application in Visual Studio debugging experience
    /// </summary>
    public virtual void StopService() {....}
}

Ich habe diese Frage gefunden, aber ich denke, eine klare und einfache Antwort fehlt.

Ich möchte meinen Debugger nicht an einen Prozess anhängen, möchte aber dennoch den Dienst OnStartund die OnStopMethoden aufrufen können. Ich möchte auch, dass es als Konsolenanwendung ausgeführt wird, damit ich Informationen von NLog auf einer Konsole protokollieren kann .

Ich habe diese brillanten Anleitungen gefunden, die dies tun:

• Debuggen eines Windows-Dienstprojekts

• Einfachere Möglichkeit zum Debuggen eines Windows-Dienstes

Ändern Sie zunächst die Projekte Output typein Console Application.

Ändern Sie Ihre Program.cs, um so auszusehen:

static class Program
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    static void Main()
    {
        // Startup as service.
        ServiceBase[] ServicesToRun;
        ServicesToRun = new ServiceBase[]
        {
            new Service1()
        };

        if (Environment.UserInteractive)
        {
            RunInteractive(ServicesToRun);
        }
        else
        {
            ServiceBase.Run(ServicesToRun);
        }
    }
}

Fügen Sie dann die folgende Methode hinzu, damit Dienste im interaktiven Modus ausgeführt werden können.

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

Ich verwende ein großartiges Nuget-Paket namens ServiceProcess.Helpers.

Und ich zitiere...

Es unterstützt das Debuggen von Windows-Diensten, indem es eine Benutzeroberfläche zum Abspielen / Stoppen / Anhalten erstellt, wenn ein Debugger angeschlossen ist, ermöglicht jedoch auch die Installation und Ausführung des Dienstes in der Windows Server-Umgebung.

All dies mit einer Codezeile.

http://windowsservicehelper.codeplex.com/

Nach der Installation und Verkabelung müssen Sie lediglich Ihr Windows-Dienstprojekt als Startprojekt festlegen und auf Ihrem Debugger auf Start klicken.

Wenn Sie zu Beginn eines Windows-Dienstvorgangs versuchen, etwas zu debuggen, funktioniert das "Anhängen" an den laufenden Prozess leider nicht. Ich habe versucht, Debugger.Break () in der OnStart-Prozedur zu verwenden, aber mit einer 64-Bit-kompilierten Visual Studio 2010-Anwendung gibt der Befehl break nur einen Fehler wie den folgenden aus:

System error 1067 has occurred.

Zu diesem Zeitpunkt müssen Sie in Ihrer Registrierung die Option "Image File Execution" für Ihre ausführbare Datei einrichten. Die Einrichtung dauert fünf Minuten und funktioniert sehr gut. Hier ist ein Microsoft-Artikel mit folgenden Details:

Gewusst wie: Starten Sie den Debugger automatisch

Probieren Sie die eigene Post-Build-Ereignisbefehlszeile von Visual Studio aus .

Versuchen Sie dies im Post-Build hinzuzufügen:

@echo off
sc query "ServiceName" > nul
if errorlevel 1060 goto install
goto stop

:delete
echo delete
sc delete "ServiceName" > nul
echo %errorlevel%
goto install

:install
echo install
sc create "ServiceName" displayname= "Service Display Name" binpath= "$(TargetPath)" start= auto > nul
echo %errorlevel%
goto start

:start
echo start
sc start "ServiceName" > nul
echo %errorlevel%
goto end

:stop
echo stop
sc stop "ServiceName" > nul
echo %errorlevel%
goto delete

:end

Wenn der Build-Fehler mit einer Meldung wie Error 1 The command "@echo off sc query "ServiceName" > nulso weiter, Ctrl+ Cdann Ctrl+V die Fehlermeldung in Notepad und schauen Sie sich den letzten Satz der Nachricht an.

Es könnte heißen exited with code x. Suchen Sie hier nach dem Code in einem häufigen Fehler und sehen Sie, wie Sie ihn beheben können.

1072 -- Marked for deletion → Close all applications that maybe using the service including services.msc and Windows event log.
1058 -- Can't be started because disabled or has no enabled associated devices → just delete it.
1060 -- Doesn't exist → just delete it.
1062 -- Has not been started → just delete it.
1053 -- Didn't respond to start or control → see event log (if logged to event log). It may be the service itself throwing an exception.
1056 -- Service is already running → stop the service, and then delete.

Mehr zu Fehlercodes hier .

Und wenn der Build-Fehler mit Meldung wie dieser,

Error    11    Could not copy "obj\x86\Debug\ServiceName.exe" to "bin\Debug\ServiceName.exe". Exceeded retry count of 10. Failed.    ServiceName
Error    12    Unable to copy file "obj\x86\Debug\ServiceName.exe" to "bin\Debug\ServiceName.exe". The process cannot access the file 'bin\Debug\ServiceName.exe' because it is being used by another process.    ServiceName

Öffnen Sie cmd und versuchen Sie dann, es zuerst mit zu töten taskkill /fi "services eq ServiceName" /f

Wenn alles F5in Ordnung ist, sollte es ausreichen, um es zu debuggen.

Führen Sie in der OnStartMethode die folgenden Schritte aus.

protected override void OnStart(string[] args)
{
    try
    {
        RequestAdditionalTime(600000);
        System.Diagnostics.Debugger.Launch(); // Put breakpoint here.

        .... Your code
    }
    catch (Exception ex)
    {
        .... Your exception code
    }
}

Führen Sie dann eine Eingabeaufforderung als Administrator aus und geben Sie Folgendes ein:

c:\> sc create test-xyzService binPath= <ProjectPath>\bin\debug\service.exe type= own start= demand

In der obigen Zeile wird test-xyzService in der Serviceliste erstellt.

Um den Dienst zu starten, werden Sie aufgefordert, eine Verbindung zum Debüt in Visual Studio herzustellen oder nicht.

c:\> sc start text-xyzService

So beenden Sie den Dienst:

c:\> sc stop test-xyzService

So löschen oder deinstallieren Sie:

c:\> sc delete text-xyzService

Debuggen Sie einen Windows-Dienst über http (getestet mit VS 2015 Update 3 und .Net FW 4.6).

Zunächst müssen Sie in Ihrer VS-Lösung ein Konsolenprojekt erstellen (Hinzufügen -> Neues Projekt -> Konsolenanwendung).

Erstellen Sie im neuen Projekt eine Klasse "ConsoleHost" mit diesem Code:

class ConsoleHost : IDisposable
{
    public static Uri BaseAddress = new Uri(http://localhost:8161/MyService/mex);
    private ServiceHost host;

    public void Start(Uri baseAddress)
    {
        if (host != null) return;

        host = new ServiceHost(typeof(MyService), baseAddress ?? BaseAddress);

        //binding
        var binding = new BasicHttpBinding()
        {
            Name = "MyService",
            MessageEncoding = WSMessageEncoding.Text,
            TextEncoding = Encoding.UTF8,
            MaxBufferPoolSize = 2147483647,
            MaxBufferSize = 2147483647,
            MaxReceivedMessageSize = 2147483647
        };

        host.Description.Endpoints.Clear();
        host.AddServiceEndpoint(typeof(IMyService), binding, baseAddress ?? BaseAddress);

        // Enable metadata publishing.
        var smb = new ServiceMetadataBehavior
        {
            HttpGetEnabled = true,
            MetadataExporter = { PolicyVersion = PolicyVersion.Policy15 },
        };

        host.Description.Behaviors.Add(smb);

        var defaultBehaviour = host.Description.Behaviors.OfType<ServiceDebugBehavior>().FirstOrDefault();
        if (defaultBehaviour != null)
        {
            defaultBehaviour.IncludeExceptionDetailInFaults = true;
        }

        host.Open();
    }

    public void Stop()
    {
        if (host == null)
            return;

        host.Close();
        host = null;
    }

    public void Dispose()
    {
        this.Stop();
    }
}

Und dies ist der Code für die Program.cs-Klasse:

public static class Program
{
    [STAThread]
    public static void Main(string[] args)
    {
        var baseAddress = new Uri(http://localhost:8161/MyService);
        var host = new ConsoleHost();
        host.Start(null);
        Console.WriteLine("The service is ready at {0}", baseAddress);
        Console.WriteLine("Press <Enter> to stop the service.");
        Console.ReadLine();
        host.Stop();
    }
}

Konfigurationen wie Verbindungszeichenfolgen sollten in die Datei App.config des Konsolenprojekts kopiert werden.

Um die Konsole zu öffnen, klicken Sie mit der rechten Maustaste auf Konsolenprojekt und klicken Sie auf Debuggen -> Neue Instanz starten.

Fügen Sie Ihrer Serviceklasse einfach einen Konstruktor hinzu (falls Sie ihn noch nicht haben). Unten können Sie ein Beispiel für Visual Basic .net finden.

Public Sub New()
   OnStart(Nothing) 
End Sub

Klicken Sie anschließend mit der rechten Maustaste auf das Projekt und wählen Sie " Debuggen -> Neue Instanz starten ".