Samouczek: tworzenie aplikacji usługi systemu Windows

  • Artykuł

Ostrzeżenie

Ta dokumentacja nie dotyczy najnowszej wersji usługi systemu Windows. Aby uzyskać najnowszą zawartość w usługach systemu Windows korzystających z usługi BackgroundService i szablonu usługi procesu roboczego, zobacz:

W tym artykule pokazano, jak utworzyć aplikację usługi systemu Windows w programie 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 Plik programu Visual Studio wybierz pozycję Nowy>projekt (lub naciśnij klawisze Ctrl+Shift+N), aby otworzyć okno Nowy projekt .

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

    Uwaga

    Jeśli nie widzisz szablonu usługi systemu Windows, może być konieczne zainstalowanie obciążenia programowanie aplikacji klasycznych platformy .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 [Projekt] lub Service1.vb [Projekt]).

    Szablon projektu zawiera klasę składników o nazwie Service1 , która dziedziczy z System.ServiceProcess.ServiceBaseklasy . Zawiera on większość 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.

    Monit o zmianę nazwy monitu

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

    Właściwości usługi systemu

  4. Wybierz pozycję Zapisz wszystko z menu Plik .

Dodawanie funkcji do usługi

W tej sekcji dodasz niestandardowy dziennik zdarzeń do usługi systemu Windows. Składnik EventLog jest przykładem typu składnika, który można dodać do usługi systemu 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ę Wyświetl Projektant.

  2. W przyborniku rozwiń węzeł Składniki, a następnie przeciągnij składnik EventLog do karty Service1.cs [Projektowanie] 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 języka 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 . Program Visual Studio automatycznie utworzył 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 powró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ę do pliku usingMyNewService.cs lub instrukcję Imports do pliku System.TimersMyNewService.vb dla 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 zapisania w dzienniku zdarzeń:

    private int eventId = 1;

    Private eventId As Integer = 1

  4. MyNewService W klasie dodaj metodę OnTimer do obsługi Timer.Elapsed zdarzenia:

    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 roboczych w tle. Aby uzyskać więcej informacji, zobacz System.ComponentModel.BackgroundWorker.

Definiowanie, co się dzieje po zatrzymaniu usługi

Wstaw wiersz kodu w metodzie OnStop , 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 , i OnShutdown w OnContinuecelu zdefiniowania dodatkowego przetwarzania dla składnika.

Poniższy kod pokazuje, jak można zastąpić metodę OnContinueMyNewService w 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, która dziedziczy po ServiceBase raportach 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ę SetServiceStatus systemu Windows.

Implementowanie stanu oczekiwania na usługę

  1. Dodaj instrukcję do pliku usingMyNewService.cs lub instrukcję Imports do pliku System.Runtime.InteropServicesMyNewService.vb dla 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 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

    Menedżer sterowania usługami używa elementów dwWaitHint i dwCheckpointstruktury SERVICE_STATUS , aby określić, ile czasu należy poczekać na uruchomienie lub zamknięcie usługi systemu 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 z przyrostową dwCheckPoint wartością.

  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 działania 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 systemu Windows należy ją zainstalować, co spowoduje zarejestrowanie jej w Menedżerze sterowania usługami. 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ę Wyświetl Projektant.

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

    Domyślnie program 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 procesu skojarzonego z usługą.

  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, takiej jak przykładowa usługa.

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

    Opis usługi w oknie Usługi.

  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 , czyli nazwy używanej przez system (na przykład nazwy używanej net start przez polecenie 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ć podobnie do poniższego:

    Właściwości instalatora dla

  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ń należy rozważyć użycie LocalService konta, które działa jako użytkownik nieuprzywilejowany 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 w użyciu i analiz, a użytkownik może łatwo je zastąpić, może być trudniejsze do odnalezienia i użycia 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 systemu Windows może akceptować argumenty wiersza polecenia lub parametry uruchamiania. Po dodaniu kodu do procesu 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 na stałe, ustaw je w rejestrze.

Każda usługa systemu 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 systemu 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 plik Program.cs lub MyNewService.Projektant. 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ń konstruktor, MyNewService 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 systemu Windows. Aby usługa uruchamiała się poprawnie, użytkownik musi podać znaki cudzysłowu dla ścieżki i każdego parametru. Użytkownik może zmienić parametry we wpisie rejestru ImagePath , aby zmienić parametry uruchamiania usługi systemu Windows. Jednak lepszym sposobem jest 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.

    Pojawią się strony właściwości projektu.

  2. Na karcie Aplikacja na liście Obiekt startowy 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 klawisze Ctrl+Shift+B).

Instalowanie usługi

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

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

  2. W wierszu polecenia dewelopera dla programu 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 proces installutil.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 truewartość .
    • 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 systemie Windows otwórz aplikację klasyczną Usługi . Naciśnij klawisze 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 alfabetycznie według nazwy wyświetlanej ustawionej dla niej.

    MyNewService w oknie Usługi.

  2. Aby uruchomić usługę, wybierz pozycję Uruchom 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 poleceń 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 systemie Windows otwórz aplikację klasyczną Podgląd zdarzeń. Wprowadź Podgląd zdarzeń na pasku wyszukiwania systemu Windows, a następnie wybierz Podgląd zdarzeń z wyników wyszukiwania.

    Porada

    W programie Visual Studio można uzyskać dostęp do dzienników zdarzeń, otwierając Eksploratora serwera z menu Widok (lub naciskając klawisze Ctrl+Alt+S) 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ę.

    Użyj Podgląd zdarzeń, aby wyświetlić wpisy dziennika zdarzeń

Czyszczenie zasobów

Jeśli aplikacja usługi systemu Windows nie jest już potrzebna, możesz ją usunąć.

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

  2. W oknie Wiersza polecenia dla deweloperów programu Visual Studio 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, który będzie używany do instalowania usługi systemu Windows. Użyj zestawu narzędzi WiX , aby utworzyć instalatora dla usługi systemu 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ń podczas uruchamiania 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ż