Samouczek: tworzenie aplikacji usługi Windows

Ostrzeżenie

Ta dokumentacja nie jest przeznaczona dla najnowszej wersji usługi Windows Service. Aby uzyskać najnowszą zawartość dotyczącą usług Windows przy użyciu BackgroundService i szablonu usługi procesu roboczego, zobacz:

W tym artykule pokazano, jak utworzyć aplikację usługi Windows w Visual Studio, która zapisuje komunikaty w dzienniku zdarzeń.

Tworzenie usługi

Aby rozpocząć, utwórz projekt i ustaw wartości wymagane do poprawnego działania usługi.

  1. W menu Visual Studio Plik wybierz pozycję Nowy>Project (lub naciśnij klawiszeCtrlShiftN++), aby otworzyć okno Nowy Project.

  2. Znajdź i wybierz szablon projektu usługi Windows (.NET Framework).

    Uwaga

    Jeśli nie widzisz szablonu usługi Windows, może być konieczne zainstalowanie obciążenia programistycznego dla komputerów .NET przy użyciu Instalator programu Visual Studio.

  3. W polu Nazwa wprowadź ciąg MyNewService, a następnie wybierz przycisk OK.

    Zostanie wyświetlona karta Projekt (Service1.cs [Projektowanie] lub Service1.vb [Projekt]).

    Szablon projektu zawiera klasę składników o nazwie Service1 , która dziedziczy z System.ServiceProcess.ServiceBaseklasy . Zawiera on wiele podstawowego kodu usługi, takiego jak kod umożliwiający uruchomienie usługi.

Zmienianie nazwy usługi

Zmień nazwę usługi z Service1 na MyNewService.

  1. W Eksplorator rozwiązań wybierz pozycję Service1.cs lub Service1.vb, a następnie wybierz pozycję Zmień nazwę z menu skrótów. Zmień nazwę pliku na MyNewService.cs lub MyNewService.vb, a następnie naciśnij klawisz Enter

    Zostanie wyświetlone okno podręczne z pytaniem, czy chcesz zmienić nazwę wszystkich odwołań do elementu kodu Service1.

  2. W oknie podręcznym wybierz pozycję Tak.

    Rename prompt

  3. Na karcie Projektowanie wybierz pozycję Właściwości z menu skrótów. W oknie Właściwości zmień wartość ServiceName na MyNewService.

    Service properties

  4. Wybierz pozycję Zapisz wszystko z menu Plik .

Dodawanie funkcji do usługi

W tej sekcji dodasz niestandardowy dziennik zdarzeń do usługi Windows. Składnik EventLog jest przykładem typu składnika, który można dodać do usługi Windows.

Dodawanie niestandardowych funkcji dziennika zdarzeń

  1. W Eksplorator rozwiązań z menu skrótów dla pliku MyNewService.cs lub MyNewService.vb wybierz pozycję Projektant widoków.

  2. W przyborniku rozwiń węzeł Składniki, a następnie przeciągnij składnik EventLog do karty Service1.cs [Design] lub Service1.vb [Projektowanie].

  3. W Eksplorator rozwiązań z menu skrótów dla pliku MyNewService.cs lub MyNewService.vb wybierz pozycję Wyświetl kod.

  4. Zdefiniuj niestandardowy dziennik zdarzeń.

    W języku C# zmodyfikuj istniejący MyNewService() konstruktor, jak pokazano w poniższym fragmencie kodu. W przypadku Visual Basic dodaj New() konstruktor, jak pokazano w poniższym fragmencie kodu.

    public MyNewService()
    {
        InitializeComponent();
        eventLog1 = new System.Diagnostics.EventLog();
        if (!System.Diagnostics.EventLog.SourceExists("MySource"))
        {
            System.Diagnostics.EventLog.CreateEventSource(
                "MySource","MyNewLog");
        }
        eventLog1.Source = "MySource";
        eventLog1.Log = "MyNewLog";
    }
    
    ' To access the constructor in Visual Basic, select New from the
    ' method name drop-down list. 
    Public Sub New()
        MyBase.New()
        InitializeComponent()
        Me.EventLog1 = New System.Diagnostics.EventLog
        If Not System.Diagnostics.EventLog.SourceExists("MySource") Then
            System.Diagnostics.EventLog.CreateEventSource("MySource",
            "MyNewLog")
        End If
        EventLog1.Source = "MySource"
        EventLog1.Log = "MyNewLog"
    End Sub
    
  5. Dodaj instrukcję using do pliku MyNewService.cs (jeśli jeszcze nie istnieje) lub instrukcję Imports do pliku MyNewService.vb dla System.Diagnostics przestrzeni nazw:

    using System.Diagnostics;
    
    Imports System.Diagnostics
    
  6. Wybierz pozycję Zapisz wszystko z menu Plik .

Definiowanie, co się dzieje po uruchomieniu usługi

W edytorze kodu dla pliku MyNewService.cs lub MyNewService.vb znajdź metodę OnStart . Visual Studio automatycznie utworzyła pustą definicję metody podczas tworzenia projektu. Dodaj kod, który zapisuje wpis w dzienniku zdarzeń po uruchomieniu usługi:

protected override void OnStart(string[] args)
{
    eventLog1.WriteEntry("In OnStart.");
}
' To access the OnStart in Visual Basic, select OnStart from the
' method name drop-down list. 
Protected Overrides Sub OnStart(ByVal args() As String)
    EventLog1.WriteEntry("In OnStart")
End Sub

Sondowanie

Ponieważ aplikacja usługi jest przeznaczona do długotrwałego działania, zwykle sonduje lub monitoruje system, który został skonfigurowany w metodzie OnStart . Metoda OnStart musi wrócić do systemu operacyjnego po rozpoczęciu operacji usługi, aby system nie został zablokowany.

Aby skonfigurować prosty mechanizm sondowania, użyj System.Timers.Timer składnika . Czasomierz zgłasza Elapsed zdarzenie w regularnych odstępach czasu, w którym usługa może wykonywać monitorowanie. Składnik jest używany Timer w następujący sposób:

  • Ustaw właściwości Timer składnika w metodzie MyNewService.OnStart .
  • Uruchom czasomierz, wywołując metodę Start .
Konfigurowanie mechanizmu sondowania
  1. Dodaj instrukcję using do pliku MyNewService.cs lub instrukcję Imports do pliku MyNewService.vb dla System.Timers przestrzeni nazw:

    using System.Timers;
    
    Imports System.Timers
    
  2. Dodaj następujący kod w zdarzeniu, MyNewService.OnStart aby skonfigurować mechanizm sondowania:

    // Set up a timer that triggers every minute.
    Timer timer = new Timer();
    timer.Interval = 60000; // 60 seconds
    timer.Elapsed += new ElapsedEventHandler(this.OnTimer);
    timer.Start();
    
    ' Set up a timer that triggers every minute.
    Dim timer As Timer = New Timer()
    timer.Interval = 60000 ' 60 seconds
    AddHandler timer.Elapsed, AddressOf Me.OnTimer
    timer.Start()
    
  3. MyNewService W klasie dodaj zmienną składową. Zawiera identyfikator następnego zdarzenia do zapisu w dzienniku zdarzeń:

    private int eventId = 1;
    
    Private eventId As Integer = 1
    
  4. MyNewService W klasie dodaj metodę OnTimer do obsługi zdarzeniaTimer.Elapsed:

    public void OnTimer(object sender, ElapsedEventArgs args)
    {
        // TODO: Insert monitoring activities here.
        eventLog1.WriteEntry("Monitoring the System", EventLogEntryType.Information, eventId++);
    }
    
    Private Sub OnTimer(sender As Object, e As Timers.ElapsedEventArgs)
       ' TODO: Insert monitoring activities here.
       eventLog1.WriteEntry("Monitoring the System", EventLogEntryType.Information, eventId)
       eventId = eventId + 1
    End Sub
    

Zamiast uruchamiać całą pracę w wątku głównym, można uruchamiać zadania przy użyciu wątków procesu roboczego w tle. Aby uzyskać więcej informacji, zobacz System.ComponentModel.BackgroundWorker.

Definiowanie, co się dzieje po zatrzymaniu usługi

Wstaw wiersz kodu w OnStop metodzie, który dodaje wpis do dziennika zdarzeń po zatrzymaniu usługi:

protected override void OnStop()
{
    eventLog1.WriteEntry("In OnStop.");
}
Protected Overrides Sub OnStop()
    EventLog1.WriteEntry("In OnStop.")
End Sub

Definiowanie innych akcji dla usługi

Można zastąpić OnPausemetody , OnContinuei OnShutdown w celu zdefiniowania dodatkowego przetwarzania dla składnika.

Poniższy kod pokazuje, jak zastąpić metodę OnContinue w MyNewService klasie:

protected override void OnContinue()
{
    eventLog1.WriteEntry("In OnContinue.");
}
Protected Overrides Sub OnContinue()
    EventLog1.WriteEntry("In OnContinue.")
End Sub

Ustawianie stanu usługi

Usługi zgłaszają swój stan do Menedżera kontroli usług , aby użytkownik mógł określić, czy usługa działa prawidłowo. Domyślnie usługa dziedziczona z ServiceBase raportów ograniczony zestaw ustawień stanu, w tym SERVICE_STOPPED, SERVICE_PAUSED i SERVICE_RUNNING. Jeśli uruchomienie usługi zajmuje trochę czasu, warto zgłosić stan SERVICE_START_PENDING.

Ustawienia stanu SERVICE_START_PENDING i SERVICE_STOP_PENDING można zaimplementować, dodając kod wywołujący funkcję Windows SetServiceStatus.

Implementowanie stanu oczekującego na usługę

  1. Dodaj instrukcję using do pliku MyNewService.cs lub instrukcję Imports do pliku MyNewService.vb dla System.Runtime.InteropServices przestrzeni nazw:

    using System.Runtime.InteropServices;
    
    Imports System.Runtime.InteropServices
    
  2. Dodaj następujący kod do pliku MyNewService.cs lub MyNewService.vb, aby zadeklarować ServiceState wartości i dodać strukturę stanu, która będzie używana w wywołaniu wywołania wywołania platformy:

    public enum ServiceState
    {
        SERVICE_STOPPED = 0x00000001,
        SERVICE_START_PENDING = 0x00000002,
        SERVICE_STOP_PENDING = 0x00000003,
        SERVICE_RUNNING = 0x00000004,
        SERVICE_CONTINUE_PENDING = 0x00000005,
        SERVICE_PAUSE_PENDING = 0x00000006,
        SERVICE_PAUSED = 0x00000007,
    }
    
    [StructLayout(LayoutKind.Sequential)]
    public struct ServiceStatus
    {
        public int dwServiceType;
        public ServiceState dwCurrentState;
        public int dwControlsAccepted;
        public int dwWin32ExitCode;
        public int dwServiceSpecificExitCode;
        public int dwCheckPoint;
        public int dwWaitHint;
    };
    
    Public Enum ServiceState
        SERVICE_STOPPED = 1
        SERVICE_START_PENDING = 2
        SERVICE_STOP_PENDING = 3
        SERVICE_RUNNING = 4
        SERVICE_CONTINUE_PENDING = 5
        SERVICE_PAUSE_PENDING = 6
        SERVICE_PAUSED = 7
    End Enum
    
    <StructLayout(LayoutKind.Sequential)>
    Public Structure ServiceStatus
        Public dwServiceType As Long
        Public dwCurrentState As ServiceState
        Public dwControlsAccepted As Long
        Public dwWin32ExitCode As Long
        Public dwServiceSpecificExitCode As Long
        Public dwCheckPoint As Long
        Public dwWaitHint As Long
    End Structure
    

    Uwaga

    Program Service Control Manager używa dwWaitHint elementów i dwCheckpoint struktury SERVICE_STATUS, aby określić, ile czasu oczekiwania na uruchomienie lub zamknięcie usługi Windows. Jeśli metody OnStart i OnStop działają długo, usługa może zażądać więcej czasu, wywołując SetServiceStatus ponownie wartość przyrostową dwCheckPoint .

  3. W klasie zadeklaruj MyNewService funkcję SetServiceStatus przy użyciu wywołania platformy:

    [DllImport("advapi32.dll", SetLastError = true)]
    private static extern bool SetServiceStatus(System.IntPtr handle, ref ServiceStatus serviceStatus);
    
    Declare Auto Function SetServiceStatus Lib "advapi32.dll" (ByVal handle As IntPtr, ByRef serviceStatus As ServiceStatus) As Boolean
    
  4. Aby zaimplementować stan SERVICE_START_PENDING, dodaj następujący kod na początku OnStart metody:

    // Update the service state to Start Pending.
    ServiceStatus serviceStatus = new ServiceStatus();
    serviceStatus.dwCurrentState = ServiceState.SERVICE_START_PENDING;
    serviceStatus.dwWaitHint = 100000;
    SetServiceStatus(this.ServiceHandle, ref serviceStatus);
    
    ' Update the service state to Start Pending.
    Dim serviceStatus As ServiceStatus = New ServiceStatus()
    serviceStatus.dwCurrentState = ServiceState.SERVICE_START_PENDING
    serviceStatus.dwWaitHint = 100000
    SetServiceStatus(Me.ServiceHandle, serviceStatus)
    
  5. Dodaj kod na końcu OnStart metody, aby ustawić stan na SERVICE_RUNNING:

    // Update the service state to Running.
    serviceStatus.dwCurrentState = ServiceState.SERVICE_RUNNING;
    SetServiceStatus(this.ServiceHandle, ref serviceStatus);
    
    ' Update the service state to Running.
    serviceStatus.dwCurrentState = ServiceState.SERVICE_RUNNING
    SetServiceStatus(Me.ServiceHandle, serviceStatus)
    
  6. (Opcjonalnie) Jeśli OnStop jest długotrwałą metodą, powtórz tę procedurę w metodzie OnStop . Zaimplementuj stan SERVICE_STOP_PENDING i zwróć stan SERVICE_STOPPED przed zakończeniem OnStop metody.

    Na przykład:

    // Update the service state to Stop Pending.
    ServiceStatus serviceStatus = new ServiceStatus();
    serviceStatus.dwCurrentState = ServiceState.SERVICE_STOP_PENDING;
    serviceStatus.dwWaitHint = 100000;
    SetServiceStatus(this.ServiceHandle, ref serviceStatus);
    
    // Update the service state to Stopped.
    serviceStatus.dwCurrentState = ServiceState.SERVICE_STOPPED;
    SetServiceStatus(this.ServiceHandle, ref serviceStatus);
    
    ' Update the service state to Stop Pending.
    Dim serviceStatus As ServiceStatus = New ServiceStatus()
    serviceStatus.dwCurrentState = ServiceState.SERVICE_STOP_PENDING
    serviceStatus.dwWaitHint = 100000
    SetServiceStatus(Me.ServiceHandle, serviceStatus)
    
    ' Update the service state to Stopped.
    serviceStatus.dwCurrentState = ServiceState.SERVICE_STOPPED
    SetServiceStatus(Me.ServiceHandle, serviceStatus)
    

Dodawanie instalatorów do usługi

Przed uruchomieniem usługi Windows należy ją zainstalować, co spowoduje zarejestrowanie jej w Menedżerze kontroli usług. Dodaj instalatory do projektu, aby obsłużyć szczegóły rejestracji.

  1. W Eksplorator rozwiązań z menu skrótów dla pliku MyNewService.cs lub MyNewService.vb wybierz pozycję Projektant widoków.

  2. W widoku Projekt wybierz obszar tła, a następnie wybierz pozycję Dodaj instalatora z menu skrótów.

    Domyślnie Visual Studio dodaje do projektu klasę składników o nazwie ProjectInstaller, która zawiera dwa instalatory. Te instalatory są przeznaczone dla Twojej usługi i dla skojarzonego procesu usługi.

  3. W widoku Projekt dla programu ProjectInstaller wybierz pozycję serviceInstaller1 dla projektu Visual C# lub ServiceInstaller1 dla projektu Visual Basic, a następnie wybierz pozycję Właściwości z menu skrótów.

  4. W oknie Właściwości sprawdź, czy ServiceName właściwość jest ustawiona na MyNewService.

  5. Dodaj tekst do Description właściwości, np. przykładową usługę.

    Ten tekst jest wyświetlany w kolumnie Opis okna Usługi i opisuje usługę dla użytkownika.

    Service description in the Services window.

  6. Dodaj tekst do DisplayName właściwości . Na przykład Nazwa wyświetlana MyNewService.

    Ten tekst jest wyświetlany w kolumnie Nazwa wyświetlana okna Usługi . Ta nazwa może różnić się od ServiceName właściwości , która jest nazwą używaną przez system (na przykład nazwą używaną dla net start polecenia do uruchomienia usługi).

  7. StartType Ustaw właściwość na Automatic z listy rozwijanej.

  8. Po zakończeniu okna Właściwości powinny wyglądać następująco:

    Installer Properties for a Windows service

  9. W widoku Projekt dla programu ProjectInstaller wybierz pozycję serviceProcessInstaller1 dla projektu Visual C# lub ServiceProcessInstaller1 dla projektu Visual Basic, a następnie wybierz pozycję Właściwości z menu skrótów. Account Ustaw właściwość na LocalSystem z listy rozwijanej.

    To ustawienie instaluje usługę i uruchamia ją przy użyciu lokalnego konta systemowego.

    Ważne

    Konto LocalSystem ma szerokie uprawnienia, w tym możliwość zapisywania w dzienniku zdarzeń. Należy go używać ostrożnie, ponieważ może zwiększyć ryzyko ataku przez złośliwe oprogramowanie. W przypadku innych zadań rozważ użycie LocalService konta, które działa jako użytkownik niebędący uprzywilejowanym na komputerze lokalnym i przedstawia anonimowe poświadczenia do dowolnego serwera zdalnego. Ten przykład nie powiedzie się, jeśli spróbujesz użyć LocalService konta, ponieważ wymaga uprawnień do zapisu w dzienniku zdarzeń.

Aby uzyskać więcej informacji na temat instalatorów, zobacz How to: Add installers to your service application (Instrukcje: dodawanie instalatorów do aplikacji usługi).

(Opcjonalnie) Ustawianie parametrów uruchamiania

Uwaga

Przed podjęciem decyzji o dodaniu parametrów uruchamiania należy rozważyć, czy jest to najlepszy sposób przekazywania informacji do usługi. Chociaż są one łatwe do użycia i analizowania, a użytkownik może łatwo je zastąpić, może być trudniejsza dla użytkownika do odnajdywania i używania bez dokumentacji. Ogólnie rzecz biorąc, jeśli usługa wymaga więcej niż kilku parametrów uruchamiania, należy zamiast tego użyć rejestru lub pliku konfiguracji.

Usługa Windows może akceptować argumenty wiersza polecenia lub parametry uruchamiania. Po dodaniu kodu do przetwarzania parametrów uruchamiania użytkownik może uruchomić usługę przy użyciu własnych niestandardowych parametrów uruchamiania w oknie właściwości usługi. Jednak te parametry uruchamiania nie są utrwalane przy następnym uruchomieniu usługi. Aby ustawić parametry uruchamiania trwale, ustaw je w rejestrze.

Każda usługa Windows ma wpis rejestru w podkluczu HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services. W podkluczu każdej usługi użyj podklucza Parameters , aby przechowywać informacje, do których usługa może uzyskać dostęp. Możesz użyć plików konfiguracji aplikacji dla usługi Windows w taki sam sposób, jak w przypadku innych typów programów. Aby uzyskać przykładowy kod, zobacz ConfigurationManager.AppSettings.

Aby dodać parametry uruchamiania

  1. Wybierz pozycję Program.cs lub MyNewService.Designer.vb, a następnie wybierz pozycję Wyświetl kod z menu skrótów. W metodzie Main zmień kod, aby dodać parametr wejściowy i przekazać go do konstruktora usługi:

    static void Main(string[] args)
    {
        ServiceBase[] ServicesToRun;
        ServicesToRun = new ServiceBase[]
        {
            new MyNewService(args)
        };
        ServiceBase.Run(ServicesToRun);
    }
    
    Shared Sub Main(ByVal cmdArgs() As String)
        Dim ServicesToRun() As System.ServiceProcess.ServiceBase = New System.ServiceProcess.ServiceBase() {New MyNewService(cmdArgs)}
        System.ServiceProcess.ServiceBase.Run(ServicesToRun)
    End Sub
    
  2. W pliku MyNewService.cs lub MyNewService.vb zmień MyNewService konstruktor, aby przetworzyć parametr wejściowy w następujący sposób:

    using System.Diagnostics;
    
    public MyNewService(string[] args)
    {
        InitializeComponent();
    
        string eventSourceName = "MySource";
        string logName = "MyNewLog";
    
        if (args.Length > 0)
        {
           eventSourceName = args[0];
        }
    
        if (args.Length > 1)
        {
            logName = args[1];
        }
    
        eventLog1 = new EventLog();
    
        if (!EventLog.SourceExists(eventSourceName))
        {
            EventLog.CreateEventSource(eventSourceName, logName);
        }
    
        eventLog1.Source = eventSourceName;
        eventLog1.Log = logName;
    }
    
    Imports System.Diagnostics
    
    Public Sub New(ByVal cmdArgs() As String)
        InitializeComponent()
        Dim eventSourceName As String = "MySource"
        Dim logName As String = "MyNewLog"
        If (cmdArgs.Count() > 0) Then
            eventSourceName = cmdArgs(0)
        End If
        If (cmdArgs.Count() > 1) Then
            logName = cmdArgs(1)
        End If
        eventLog1 = New EventLog()
        If (Not EventLog.SourceExists(eventSourceName)) Then
            EventLog.CreateEventSource(eventSourceName, logName)
        End If
        eventLog1.Source = eventSourceName
        eventLog1.Log = logName
    End Sub
    

    Ten kod ustawia źródło zdarzeń i nazwę dziennika zgodnie z parametrami uruchamiania, które użytkownik dostarcza. Jeśli nie podano żadnych argumentów, używa wartości domyślnych.

  3. Aby określić argumenty wiersza polecenia, dodaj następujący kod do ProjectInstaller klasy w pliku ProjectInstaller.cs lub ProjectInstaller.vb:

    protected override void OnBeforeInstall(IDictionary savedState)
    {
        string parameter = "MySource1\" \"MyLogFile1";
        Context.Parameters["assemblypath"] = "\"" + Context.Parameters["assemblypath"] + "\" \"" + parameter + "\"";
        base.OnBeforeInstall(savedState);
    }
    
    Protected Overrides Sub OnBeforeInstall(ByVal savedState As IDictionary)
        Dim parameter As String = "MySource1"" ""MyLogFile1"
        Context.Parameters("assemblypath") = """" + Context.Parameters("assemblypath") + """ """ + parameter + """"
        MyBase.OnBeforeInstall(savedState)
    End Sub
    

    Zazwyczaj ta wartość zawiera pełną ścieżkę do pliku wykonywalnego dla usługi Windows. Aby usługa uruchamiała się poprawnie, użytkownik musi podać znaki cudzysłowu dla ścieżki i każdego pojedynczego parametru. Użytkownik może zmienić parametry we wpisie rejestru ImagePath, aby zmienić parametry uruchamiania usługi Windows. Lepszym sposobem jest jednak programowa zmiana wartości i uwidocznienie funkcjonalności w przyjazny dla użytkownika sposób, na przykład przy użyciu narzędzia do zarządzania lub konfiguracji.

Tworzenie usługi

  1. W Eksplorator rozwiązań wybierz pozycję Właściwości z menu skrótów dla projektu MyNewService.

    Wyświetlone są strony właściwości projektu.

  2. Na karcie Aplikacja na liście Obiekty uruchamiania wybierz pozycję MyNewService.Program lub Sub Main dla projektów Visual Basic.

  3. Aby skompilować projekt, w Eksplorator rozwiązań wybierz pozycję Kompiluj z menu skrótów dla projektu (lub naciśnij klawiszeCtrlShiftB++).

Instalowanie usługi

Teraz, gdy utworzono usługę Windows, możesz ją zainstalować. Aby zainstalować usługę Windows, musisz mieć poświadczenia administratora na komputerze, na którym jest zainstalowana.

  1. Otwórz wiersz polecenia dla deweloperów, aby Visual Studio z poświadczeniami administracyjnymi.

  2. W wierszu polecenia dla dewelopera dla Visual Studio przejdź do folderu zawierającego dane wyjściowe projektu (domyślnie podkatalog \bin\Debug projektu).

  3. Wprowadź następujące polecenie:

    installutil MyNewService.exe
    

    Jeśli usługa zostanie pomyślnie zainstalowana, polecenie zgłosi powodzenie.

    Jeśli system nie może znaleźć installutil.exe, upewnij się, że istnieje na komputerze. To narzędzie jest instalowane z .NET Framework do folderu %windir%\Microsoft.NET\Framework[64]\<framework w wersji>. Na przykład domyślną ścieżką dla wersji 64-bitowej jest %windir%\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe.

    Jeśli procesinstallutil.exe zakończy się niepowodzeniem, sprawdź dziennik instalacji, aby dowiedzieć się, dlaczego. Domyślnie dziennik znajduje się w tym samym folderze co plik wykonywalny usługi. Instalacja może zakończyć się niepowodzeniem, jeśli:

    • Klasa RunInstallerAttribute nie jest obecna w ProjectInstaller klasie.
    • Atrybut nie jest ustawiony na true.
    • Klasa nie jest zdefiniowana ProjectInstaller jako public.

Aby uzyskać więcej informacji, zobacz Instrukcje: instalowanie i odinstalowywanie usług.

Uruchamianie i uruchamianie usługi

  1. W Windows otwórz aplikację klasyczną Usługi. Naciśnij klawisz Windows+R, aby otworzyć pole Uruchom, wprowadź ciąg services.msc, a następnie naciśnij klawisz Enter lub wybierz przycisk OK.

    Powinna zostać wyświetlona usługa wyświetlana w obszarze Usługi w kolejności alfabetycznej według nazwy wyświetlanej ustawionej dla niej.

    MyNewService in the Services window.

  2. Aby uruchomić usługę, wybierz pozycję Start z menu skrótów usługi.

  3. Aby zatrzymać usługę, wybierz pozycję Zatrzymaj z menu skrótów usługi.

  4. (Opcjonalnie) W wierszu polecenia użyj polecenia net start <service name i net stop service name>>, aby uruchomić i zatrzymać usługę.<

Weryfikowanie danych wyjściowych dziennika zdarzeń usługi

  1. W Windows otwórz aplikację klasyczną Podgląd zdarzeń. Wprowadź Podgląd zdarzeń na pasku wyszukiwania Windows, a następnie wybierz pozycję Podgląd zdarzeń z wyników wyszukiwania.

    Porada

    W Visual Studio można uzyskać dostęp do dzienników zdarzeń, otwierając Eksploratora serwera z menu Widok (lub naciśnij klawiszeCtrlAltS++) i rozwijając węzeł Dzienniki zdarzeń dla komputera lokalnego.

  2. W Podgląd zdarzeń rozwiń węzeł Dzienniki aplikacji i usług.

  3. Znajdź listę myNewLog (lub MyLogFile1 , jeśli wykonano procedurę dodawania argumentów wiersza polecenia) i rozwiń ją. Powinny zostać wyświetlone wpisy dla dwóch akcji (uruchamianie i zatrzymywanie) wykonanych przez usługę.

    Use the Event Viewer to see the event log entries

Czyszczenie zasobów

Jeśli nie potrzebujesz już aplikacji usługi Windows, możesz ją usunąć.

  1. Otwórz wiersz polecenia dla deweloperów, aby Visual Studio z poświadczeniami administracyjnymi.

  2. W wierszu polecenia dla dewelopera dla Visual Studio okna przejdź do folderu zawierającego dane wyjściowe projektu.

  3. Wprowadź następujące polecenie:

    installutil.exe /u MyNewService.exe
    

    Jeśli usługa zostanie pomyślnie odinstalowany, polecenie zgłosi, że usługa została pomyślnie usunięta. Aby uzyskać więcej informacji, zobacz Instrukcje: instalowanie i odinstalowywanie usług.

Następne kroki

Po utworzeniu usługi możesz:

  • Utwórz autonomiczny program instalacyjny dla innych użytkowników do zainstalowania usługi Windows. Użyj zestawu narzędzi WiX, aby utworzyć instalatora dla usługi Windows. Aby zapoznać się z innymi pomysłami, zobacz Tworzenie pakietu instalatora.

  • Zapoznaj się z składnikiem ServiceController , który umożliwia wysyłanie poleceń do zainstalowanej usługi.

  • Zamiast tworzyć dziennik zdarzeń po uruchomieniu aplikacji, użyj instalatora, aby utworzyć dziennik zdarzeń podczas instalowania aplikacji. Dziennik zdarzeń jest usuwany przez instalatora podczas odinstalowywania aplikacji. Aby uzyskać więcej informacji, zobacz EventLogInstaller.

Zobacz też