Łatwiejszy sposób debugowania usługi Windows

Myślę również, że posiadanie osobnej "wersji" do normalnego wykonywania i jako usługi jest dobrym rozwiązaniem, ale czy naprawdę jest wymagane dedykowanie osobnego przełącznika linii poleceń w tym celu?

Nie mogłeś po prostu zrobić:

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

To miałoby "korzyść", że możesz po prostu uruchomić aplikację za pomocą doubleclick (OK, jeśli naprawdę tego potrzebujesz) i że możesz po prostu nacisnąć F5 W Visual Studio (bez konieczności modyfikowania ustawień projektu, aby to włączyć /console Opcja).

Technicznie rzecz biorąc, Environment.UserInteractive sprawdza, czy znacznik WSF_VISIBLE jest ustawiony dla bieżącej stacji okiennej, ale czy jest jakiś inny powód, dla którego zwracałaby false, poza uruchomieniem jako usługa (nieinteraktywna)?

Kiedy skonfigurowałem nowy projekt serwisu kilka tygodni temu znalazłem ten post. Chociaż jest wiele wspaniałych sugestii, nadal nie znalazłem rozwiązania, którego chciałem: możliwość wywoływania metod klas usług OnStart i OnStop bez żadnej modyfikacji klas usług.

Rozwiązanie, które wymyśliłem, wykorzystuje Environment.Interactive tryb select running, zgodnie z sugestiami innych odpowiedzi na ten post.

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

Helper RunInteractive używa reflection do wywołania chronionych OnStart i OnStop metody:

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

To jest cały wymagany kod, ale napisałem również walkthrough z wyjaśnieniami.

To, co zwykle robię, to zamykam logikę usługi w osobnej klasie i zaczynam ją od klasy "runner". Ta klasa runner może być rzeczywistą usługą lub tylko aplikacją konsolową. Więc Twoje rozwiązanie ma (przynajmniej) 3 projekty:

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

Czasami ważne jest, aby przeanalizować, co się dzieje podczas uruchamiania usługi. dołączanie do procesu nie pomaga tutaj, ponieważ nie jesteś wystarczająco szybki, aby dołączyć debugger podczas uruchamiania usługi.

Krótka odpowiedź brzmi: używam następujących 4 linijek kodu :

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

Dodaje się je do metody OnStart usługi w następujący sposób:

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

Dla tych, którzy wcześniej tego nie robili, mam dołączone szczegółowe wskazówki poniżej , ponieważ można łatwo utknąć. Poniższe wskazówki odnoszą się do Windows 7x64 i Visual Studio 2010 Team Edition , ale powinny być również ważne dla innych środowisk.

Ważne: wdrożyć usługę w "manual" mode (używając narzędzia InstallUtil z wiersza polecenia VS lub uruchamiając przygotowany projekt instalatora usługi). Otwórz Visual Studio przed uruchamiasz serwis i załaduj rozwiązanie zawierające kod źródłowy usługi - Ustaw dodatkowe punkty przerwania zgodnie z wymaganiami w Visual Studio - a następnie uruchom usługę za pomocą Panelu sterowania usługi .

Ze względu na kod Debugger.Launch spowoduje to wyświetlenie okna dialogowego "Wystąpił nieobsługiwany wyjątek Microsoft.NET Framework w nazwie Usługi .exe ."ukazać się. Klik tak, debug Nazwa Usługi.exe Jak pokazano w zrzut ekranu:

Następnie, w systemie Windows 7 UAC może pojawić się monit o podanie danych uwierzytelniających administratora. Wprowadź je i kontynuuj Tak.:

Następnie pojawia się dobrze znane okno debugera Just-In-Time Visual Studio. Pyta, czy chcesz debugować za pomocą usuniętego debugera. Zanim klikniesz Yes , Wybierz, że nie chcesz otwierać nowej instancji (opcja 2) - nowa instancja nie byłaby pomocna, ponieważ kod źródłowy nie byłby wyświetlany. Zamiast tego należy wybrać wcześniej otwartą instancję programu Visual Studio:

Po kliknięciu Tak , Po chwili Visual Studio pokaże żółtą strzałkę w prawo w linii, w której znajduje się Instrukcja Debugger.Launch i będziesz mógł debugować swój kod (metoda MyInitOnStart, która zawiera Twoją inicjalizację).

Tłoczenie F5 kontynuuje wykonywanie natychmiast, aż do następnego punktu przerwania, który masz przygotowany został osiągnięty.

Podpowiedź: aby utrzymać działanie usługi, wybierz Debug - > Detach all. Pozwala to uruchomić klienta komunikującego się z usługą po prawidłowym uruchomieniu i zakończeniu debugowania kodu startowego. Jeśli naciśniesz Shift+F5 (stop debugging), spowoduje to zakończenie usługi. Zamiast tego należy użyć panelu sterowania usługi , aby go zatrzymać.

Uwaga, że

• Jeśli tworzysz Release, kod debugowania jest automatycznie usuwany, a usługa działa normalnie.

• Używam Debugger.Launch(), który uruchamia i dołącza debugger. Przetestowałem Debugger.Break() jak również, który nie działa , ponieważ nie ma jeszcze dołączonego debuggera podczas uruchamiania usługi (powodując błąd "1067: proces nieoczekiwanie zakończył się.").

• RequestAdditionalTime Zestawy a dłuższy czas oczekiwania na uruchomienie usługi (nie opóźnia to samego kodu, ale od razu będzie kontynuowane z instrukcją Debugger.Launch). W przeciwnym razie domyślny limit czasu uruchomienia usługi jest zbyt krótki i uruchomienie usługi nie powiedzie się, jeśli nie wywołasz base.Onstart(args) wystarczająco szybko z debuggera. Praktycznie, limit czasu 10 minut pozwala uniknąć wyświetlenia komunikatu "usługa nie odpowiedziała..." natychmiast po uruchomieniu debuggera.

• Gdy już się przyzwyczaisz ta metoda jest bardzo prosta, ponieważ wymaga tylko dodania 4 linii do istniejącego kodu usługi, co pozwala szybko uzyskać kontrolę i debugowanie.

Ten film na YouTube autorstwa Fabio Scopela wyjaśnia, jak ładnie debugować usługę Windows... faktyczna metoda robienia tego zaczyna się o 4: 45 W filmie...

Oto kod wyjaśniony w filmie... w Twoim programie.plik cs, dodaj rzeczy do sekcji debugowania...

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

        }
    }
}

W Twojej Służebności1.plik cs, Dodaj metodę OnDebug ()...

    public Service1()
    {
        InitializeComponent();
    }

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

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

    protected override void OnStop()
    {
    }

UPDATE

To podejście jest zdecydowanie najłatwiejsze:

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

Zostawiam moją oryginalną odpowiedź poniżej dla potomności.

Moje usługi mają zazwyczaj klasę, która zawiera Timer, ponieważ chcę, aby usługa sprawdzała w regularnych odstępach czasu, czy jest jakaś praca do wykonania.

Dodajemy klasę i wywołujemy StartEventLoop () podczas uruchamiania usługi. (Klasa ta może być łatwo używany również z aplikacji konsoli.)

Przyjemnym efektem ubocznym tego projektu jest to, że argumenty, za pomocą których ustawiasz Timer, mogą być użyte do opóźnienia, zanim usługa zacznie działać, dzięki czemu masz czas na ręczne dołączenie debuggera.

P. s. Jak dołączyć debugger ręcznie do uruchomionego procesu...?

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

Również robiłem następujące (już wspomniane w poprzednich odpowiedziach, ale z kompilatorem warunkowym [#if] flagi do pomaga uniknąć odpalenia w Release build).

Przestałem robić to w ten sposób, ponieważ czasami zapominamy o kompilacji w wydaniu i mamy przerwę w debuggerze w aplikacji działającej na demo klienta (żenujące!).

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

Możesz również uruchomić usługę za pomocą wiersza polecenia (sc.exe).

Osobiście uruchamiałbym kod jako samodzielny program w fazie debugowania, a gdy większość błędów zostanie usunięta, zmieniłbym na działający jako usługa.

Kiedyś miałem przełącznik linii poleceń, który uruchamiałby program jako usługę lub jako zwykłą aplikację. Następnie w moim IDE ustawiłbym przełącznik, abym mógł przejść przez mój kod.

W niektórych językach można rzeczywiście wykryć, czy działa ON w IDE, i wykonać ten przełącznik automatycznie.

Jakiego języka używasz?

Myślę, że to zależy od tego, jakiego systemu operacyjnego używasz, Vista jest znacznie trudniejsza do podłączenia do usług, ze względu na separację między sesjami.

Dwie opcje, których używałem w przeszłości to:

• Użyj GFlags (w narzędziach do debugowania dla Windows), aby skonfigurować stały debugger dla procesu. Istnieje to w kluczu rejestru "opcje wykonania pliku obrazu" i jest niezwykle przydatne. Myślę, że musisz dostosować ustawienia usługi, aby włączyć "interakcję z pulpitem". Używam tego do wszystkie rodzaje debugowania, nie tylko usługi.
• inną opcją jest oddzielenie kodu bitem, tak aby część serwisowa była zamienna z normalnym uruchomieniem aplikacji. W ten sposób możesz użyć prostej flagi wiersza poleceń i uruchomić ją jako proces (a nie Usługę), co znacznie ułatwia debugowanie.

Mam nadzieję, że to pomoże.

Użyj biblioteki TopShelf .

Utwórz aplikację konsolową, a następnie skonfiguruj konfigurację w głównym

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

        }
    }

Aby debugować usługę, po prostu naciśnij F5 w visual studio.

Aby zainstalować usługę, wpisz cmd " console.exe install "

Możesz następnie uruchomić i zatrzymać usługę w Menedżerze usług systemu windows.

Kiedy piszę usługę, umieszczam całą logikę usługi w projekcie dll i tworzę dwa "hosty", które wywołują tę bibliotekę dll, jeden jest usługą Windows, a drugi jest aplikacją wiersza poleceń.

Używam aplikacji wiersza poleceń do debugowania i dołączam debugger do prawdziwej usługi tylko dla błędów, których nie mogę odtworzyć w aplikacji wiersza poleceń.

Używam tego podejścia tylko pamiętaj, że musisz przetestować cały kod podczas pracy w prawdziwym serwisie, podczas gdy Komenda narzędzie line jest miłą pomocą debugowania, to inne środowisko i nie zachowuje się dokładnie tak, jak prawdziwa usługa.

Lubię być w stanie debugować każdy aspekt mojej usługi, w tym inicjalizację w OnStart(), jednocześnie wykonując ją z pełnym zachowaniem usługi w ramach SCM... brak trybu "konsola" lub "aplikacja".

Robię to, tworząc drugą usługę, w tym samym projekcie, do wykorzystania do debugowania. Usługa debugowania, po uruchomieniu jak zwykle (np. w wtyczce services MMC), tworzy proces hosta usługi. Daje to proces dołączania debuggera, nawet jeśli jeszcze nie zacząłeś prawdziwej służby. Po podłączeniu debuggera do procesu uruchom rzeczywistą usługę i możesz się do niej włamać w dowolnym miejscu cyklu życia usługi, w tym OnStart ().

Ponieważ wymaga bardzo minimalnego włamania do kodu, usługa debugowania może być łatwo włączona do projektu konfiguracji usługi i łatwo usunięta z wydania produkcyjnego, komentując pojedynczą linię kodu i usuwając pojedynczy projekt instalator.

Szczegóły:

1) zakładając, że wdrażasz MyService, Utwórz również MyServiceDebug. Dodaj oba do tablicy ServiceBase w Program.cs tak:

    /// <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) Dodaj rzeczywistą usługę i usługę debugowania do instalatora projektu dla projektu usługi:

Obie usługi (real i debug) są uwzględniane po dodaniu wyjścia projektu usługi do projektu konfiguracji usługi. Po instalacji obie usługi pojawią się w serwisie.msc MMC plugin.

3) Uruchom usługę debugowania w MMC.

4) w programie Visual Studio Dołącz debugger do procesu rozpoczętego przez usługę debugowania.

5) Uruchom prawdziwą usługę i ciesz się debugowaniem.

Podczas tworzenia i debugowania usługi Windows zazwyczaj uruchamiam ją jako aplikację konsolową, dodając parametr startowy / console i sprawdzając to. Ułatwia życie.

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

A co z debuggerem?Break () w pierwszej linii?

Aby debugować usługi Windows łączę GFlags i a .plik reg utworzony przez regedit.

1. Uruchom GFlags, podając nazwę exe i vsjitdebugger
2. Uruchom regedit i przejdź do miejsca, w którym GFlags ustawia swoje opcje
3. wybierz "Eksportuj klucz" z menu Plik
4. zapisz ten plik gdzieś z .rozszerzenie reg
5. w każdej chwili, gdy chcesz debugować usługę: doubleclick on the.plik reg
6. Jeśli chcesz przestać debugować, kliknij dwukrotnie na sekundę .reg plik

Lub zapisz następujące fragmenty i zamień nazwę usługi.exe z żądaną nazwą wykonywalną.

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"

Do rutynowego programowania małych rzeczy zrobiłem bardzo prosty trik, aby łatwo debugować mój serwis:

Po uruchomieniu usługi sprawdzam parametr wiersza poleceń "/ debug". Jeśli usługa jest wywoływana z tym parametrem, nie robię zwykłego uruchamiania usługi, ale zamiast tego uruchamiam wszystkie słuchacze i wyświetlam messagebox "Debug in progress, naciśnij ok, aby zakończyć".

Więc jeśli moja usługa zostanie uruchomiona w zwykły sposób, uruchomi się jako usługa, jeśli zostanie uruchomiona z wiersza poleceń parametr / debugowanie będzie działać jak normalny program.

W VS po prostu dodam / debug jako parametr debugowania i uruchomię program serwisowy bezpośrednio.

W ten sposób mogę łatwo debugować większość małych problemów. Oczywiście niektóre rzeczy nadal będą musiały być debugowane jako usługa, ale dla 99% jest to wystarczająco dobre.

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

Używam wariacji na temat odpowiedzi JOP ' a. Za pomocą parametrów wiersza poleceń można ustawić tryb debugowania w IDE z właściwościami projektu lub za pośrednictwem Menedżera usług systemu Windows.

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

To jest trochę po pytaniu, ale może być przydatne w przyszłości.

Jeśli możesz, sugeruję skorzystanie z doskonałego projektu TopShelf . To sprawia, że rozwój i debugowanie usługi Windows znacznie łatwiejsze i dodaje sprawia, że wdrożenie nieco łatwiejsze zbyt.

Zobacz: http://topshelf-project.com/

Do rozwiązywania problemów w istniejącym programie serwisowym Windows, użyj ' Debugger.Break () ' jak sugerowali inni.

Dla nowego programu serwisowego Windows, sugerowałbym użycie metody Jamesa Michaela Hare ' a http://geekswithblogs.net/BlackRabbitCoder/archive/2011/03/01/c-toolbox-debug-able-self-installable-windows-service-template-redux.aspx{[4]

Po prostu umieść swój debugger w dowolnym miejscu i dołącz Visualstudio przy starcie

#if DEBUG
    Debugger.Launch();
#endif

Musisz również uruchomić VS jako administrator i musisz zezwolić, aby proces mógł być automatycznie debugowany przez innego użytkownika (jak wyjaśniono tutaj):

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

Użyj szablonu usługi Windows C # project, aby utworzyć nową aplikację usługową https://github.com/HarpyWar/windows-service-template

Są automatycznie wykrywane tryb konsoli/usługi, automatyczny instalator / deinstalator usługi i kilka najczęściej używanych funkcji.

Oto prosta metoda, której użyłem do przetestowania usługi, bez żadnych dodatkowych metod "debugowania"i ze zintegrowanymi testami jednostkowymi.

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

Masz dwie opcje do debugowania.

1. Utwórz plik dziennika: osobiście wolę osobny plik dziennika, taki jak plik tekstowy, raczej używając dziennika aplikacji lub dziennika zdarzeń.Ale to będzie kosztować dużo w imieniu czasu, ponieważ wciąż trudno jest zrozumieć nasze, gdzie dokładna lokalizacja błędu jest
2. Konwertuj aplikację na aplikację konsolową : umożliwi Ci to wszystkie narzędzia debugowania, których możemy użyć w VS.

Proszę o zapoznanie się z tym wpisem na blogu, który stworzony dla tematu.

Po prostu wklej

Debugger.Break();

Na Przykład,

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

Uderzy {[2] } Kiedy uruchomisz swój program.

Najlepszą opcją jest użycie systemu ' .Diagnostyka ' przestrzeń nazw.

Załącz swój kod W if else block dla trybu debugowania i trybu Wydania, jak pokazano poniżej, aby przełączać się między trybem debugowania i trybu wydania w 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