Zelfstudie: Een Windows-service-app maken

Artikel
04/08/2023

Waarschuwing

Deze documentatie is niet bedoeld voor de nieuwste versie van Windows-service. Zie voor de meest recente inhoud in Windows Services met BackgroundService en de sjabloon Worker Service:

In dit artikel ziet u hoe u een Windows-service-app maakt in Visual Studio die berichten naar een gebeurtenislogboek schrijft.

Een service maken

Maak eerst het project en stel de waarden in die nodig zijn om de service correct te laten functioneren.

Selecteer in het menu Bestand van Visual Studio de optie Nieuw>project (of druk op Ctrl+Shift+N) om het venster Nieuw project te openen.
Zoek en selecteer de projectsjabloon Windows-service (.NET Framework).

Notitie

Als u de Windows-servicesjabloon niet ziet, moet u mogelijk de workload .NET Desktop Development installeren met behulp van Visual Studio Installer.
Bij Naam voert u MyNewService in en selecteert u OK.

Het tabblad Ontwerpen wordt weergegeven (Service1.cs [Ontwerp] of Service1.vb [Ontwerp]).

De projectsjabloon bevat een onderdeelklasse met de naam Service1 die wordt overgenomen van System.ServiceProcess.ServiceBase. Het bevat een groot deel van de basisservicecode, zoals de code om de service te starten.

De naam van de service wijzigen

Wijzig de naam van de service van Service1 in MyNewService.

Selecteer in Solution ExplorerService1.cs of Service1.vb en kies Naam wijzigen in het snelmenu. Wijzig de naam van het bestand in MyNewService.cs of MyNewService.vb en druk op Enter

Er wordt een pop-upvenster weergegeven waarin u wordt gevraagd of u de naam van alle verwijzingen naar het code-element Service1 wilt wijzigen.
Selecteer Ja in het pop-upvenster.
Selecteer op het tabblad Ontwerpde optie Eigenschappen in het snelmenu. Wijzig in het venster Properties de waarde ServiceName in MyNewService.
Selecteer Alles opslaan in het menu Bestand .

Functies toevoegen aan de service

In deze sectie voegt u een aangepast gebeurtenislogboek toe aan de Windows-service. Het EventLog onderdeel is een voorbeeld van het type onderdeel dat u kunt toevoegen aan een Windows-service.

Functionaliteit voor aangepast gebeurtenislogboek toevoegen

Kies in Solution Explorer in het snelmenu voor MyNewService.cs of MyNewService.vb de optie Weergave Designer.
Vouw in Werksetde optie Onderdelen uit en sleep het onderdeel EventLog naar het tabblad Service1.cs [Ontwerp] of Service1.vb [Ontwerp].
Kies in Solution Explorer in het snelmenu voor MyNewService.cs of MyNewService.vb de optie Code weergeven.

Een aangepast gebeurtenislogboek definiëren.

Bewerk voor C# de bestaande MyNewService() constructor zoals weergegeven in het volgende codefragment. Voeg voor Visual Basic de New() constructor toe, zoals wordt weergegeven in het volgende codefragment.

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

Voeg een using instructie toe aan MyNewService.cs (als deze nog niet bestaat) of een Imports instructie aan MyNewService.vb voor de System.Diagnostics naamruimte:
```
using System.Diagnostics;
```
```
Imports System.Diagnostics
```
Selecteer Alles opslaan in het menu Bestand .

Definiëren wat er gebeurt wanneer de service wordt gestart

Zoek OnStart de methode in de code-editor voor MyNewService.cs of MyNewService.vb. Visual Studio heeft automatisch een lege methodedefinitie gemaakt toen u het project maakte. Voeg code toe waarmee een vermelding naar het gebeurtenislogboek wordt geschreven wanneer de service wordt gestart:

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

Navragen

Omdat een servicetoepassing is ontworpen om lang te worden uitgevoerd, wordt het systeem, dat u in de OnStart methode hebt ingesteld, meestal gecontroleerd of bewaakt. De OnStart methode moet terugkeren naar het besturingssysteem nadat de bewerking van de service is gestart, zodat het systeem niet wordt geblokkeerd.

Als u een eenvoudig polling-mechanisme wilt instellen, gebruikt u het System.Timers.Timer onderdeel. De timer genereert een Elapsed gebeurtenis met regelmatige tussenpozen, waarna uw service de bewaking kan uitvoeren. U gebruikt het Timer onderdeel als volgt:

Stel de eigenschappen van het Timer onderdeel in de MyNewService.OnStart -methode in.
Start de timer door de Start methode aan te roepen.

Het pollingmechanisme instellen

Voeg een using instructie toe aan MyNewService.cs of een Imports instructie aan MyNewService.vb voor de System.Timers naamruimte:
```
using System.Timers;
```
```
Imports System.Timers
```

Voeg de volgende code toe in de MyNewService.OnStart gebeurtenis om het pollingmechanisme in te stellen:

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

Voeg in de MyNewService klasse een lidvariabele toe. Deze bevat de id van de volgende gebeurtenis die in het gebeurtenislogboek moet worden geschreven:
```
private int eventId = 1;
```
```
Private eventId As Integer = 1
```

Voeg in de MyNewService klasse de methode toe om de OnTimerTimer.Elapsed gebeurtenis af te handelen:

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

In plaats van al uw werk op de hoofdthread uit te voeren, kunt u taken uitvoeren met behulp van achtergrondwerkthreads. Voor meer informatie raadpleegt u System.ComponentModel.BackgroundWorker.

Definiëren wat er gebeurt wanneer de service wordt gestopt

Voeg een regel code in de OnStop methode in waarmee een vermelding aan het gebeurtenislogboek wordt toegevoegd wanneer de service wordt gestopt:

protected override void OnStop()
{
    eventLog1.WriteEntry("In OnStop.");
}

Protected Overrides Sub OnStop()
    EventLog1.WriteEntry("In OnStop.")
End Sub

Andere acties voor de service definiëren

U kunt de OnPausemethoden , OnContinueen OnShutdown overschrijven om aanvullende verwerking voor uw onderdeel te definiëren.

De volgende code laat zien hoe u de OnContinue methode in de MyNewService klasse kunt overschrijven:

protected override void OnContinue()
{
    eventLog1.WriteEntry("In OnContinue.");
}

Protected Overrides Sub OnContinue()
    EventLog1.WriteEntry("In OnContinue.")
End Sub

Servicestatus instellen

Services rapporteren hun status aan Service Control Manager , zodat een gebruiker kan zien of een service correct werkt. Standaard rapporteert een service die overneemt van ServiceBase een beperkte set statusinstellingen, waaronder SERVICE_STOPPED, SERVICE_PAUSED en SERVICE_RUNNING. Als het even duurt voordat een service is opgestart, is het handig om een SERVICE_START_PENDING status te rapporteren.

U kunt de SERVICE_START_PENDING- en SERVICE_STOP_PENDING-statusinstellingen implementeren door code toe te voegen waarmee de functie Windows SetServiceStatus wordt aangeroepen.

Service in behandelingsstatus implementeren

Voeg een using instructie toe aan MyNewService.cs of een Imports instructie aan MyNewService.vb voor de System.Runtime.InteropServices naamruimte:
```
using System.Runtime.InteropServices;
```
```
Imports System.Runtime.InteropServices
```

Voeg de volgende code toe aan MyNewService.cs of MyNewService.vb om de ServiceState waarden te declareren en een structuur toe te voegen voor de status, die u gebruikt in een platform-aanroep:

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

Notitie

Service Control Manager maakt gebruik van de dwWaitHint leden en dwCheckpoint van de SERVICE_STATUS-structuur om te bepalen hoe lang moet worden gewacht totdat een Windows-service wordt gestart of afgesloten. Als uw OnStart methoden en OnStop lang duren, kan uw service meer tijd aanvragen door opnieuw aan te roepen SetServiceStatus met een incrementele dwCheckPoint waarde.

Declareer in de MyNewService klasse de functie SetServiceStatus met behulp van platform-aanroep:

[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

Als u de SERVICE_START_PENDING-status wilt implementeren, voegt u de volgende code toe aan het begin van de OnStart methode:

// 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)

Voeg code toe aan het einde van de OnStart methode om de status in te stellen op 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)

(Optioneel) Als OnStop een langdurige methode is, herhaalt u deze procedure in de OnStop methode. Implementeer de SERVICE_STOP_PENDING status en retourneer de SERVICE_STOPPED status voordat de OnStop methode wordt afgesloten.

Bijvoorbeeld:

// 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)

Installatieprogramma's toevoegen aan de service

Voordat u een Windows-service uitvoert, moet u deze installeren, waardoor deze wordt geregistreerd bij Service Control Manager. Voeg installatieprogramma's toe aan uw project om de registratiegegevens te verwerken.

Kies in Solution Explorer in het snelmenu voor MyNewService.cs of MyNewService.vbde optie Weergave Designer.
Selecteer in de ontwerpweergave het achtergrondgebied en kies vervolgens Installatieprogramma toevoegen in het snelmenu.

Visual Studio voegt standaard een onderdeelklasse met de naam ProjectInstaller, die twee installatieprogramma's bevat, toe aan uw project. Deze installatieprogramma's zijn bedoeld voor uw service en voor het bijbehorende proces van de service.
Selecteer in de ontwerpweergave voor ProjectInstallerserviceInstaller1 voor een Visual C#-project of ServiceInstaller1 voor een Visual Basic-project en kies vervolgens Eigenschappen in het snelmenu.
Controleer in het venster Properties of de ServiceName eigenschap is ingesteld op MyNewService.
Voeg tekst toe aan de Description eigenschap, zoals een voorbeeldservice.

Deze tekst wordt weergegeven in de kolom Beschrijving van het venster Services en beschrijft de service aan de gebruiker.
Voeg tekst toe aan de DisplayName eigenschap. Bijvoorbeeld MyNewService-weergavenaam.

Deze tekst wordt weergegeven in de kolom Weergavenaam van het venster Services . Deze naam kan afwijken van de ServiceName eigenschap, de naam die het systeem gebruikt (bijvoorbeeld de naam die u gebruikt voor de net start opdracht om uw service te starten).
Stel de StartType eigenschap in op Automatic in de vervolgkeuzelijst.
Wanneer u klaar bent, moeten de vensters Eigenschappen eruitzien zoals in de volgende afbeelding:
Kies in de ontwerpweergave voor ProjectInstallerde optie serviceProcessInstaller1 voor een Visual C#-project of ServiceProcessInstaller1 voor een Visual Basic-project en kies eigenschappen in het snelmenu. Stel de Account eigenschap in op LocalSystem in de vervolgkeuzelijst.

Met deze instelling wordt de service geïnstalleerd en uitgevoerd met behulp van het lokale systeemaccount.

Belangrijk

Het LocalSystem account heeft brede machtigingen, waaronder de mogelijkheid om naar het gebeurtenislogboek te schrijven. Wees voorzichtig met dit account, omdat dit het risico op aanvallen van schadelijke software kan vergroten. Voor andere taken kunt u overwegen het LocalService account te gebruiken, dat als een niet-bevoegde gebruiker op de lokale computer fungeert en anonieme referenties aan elke externe server presenteert. Dit voorbeeld mislukt als u het LocalService account probeert te gebruiken, omdat het toestemming nodig heeft om naar het gebeurtenislogboek te schrijven.

Zie Procedure: Installatieprogramma's toevoegen aan uw servicetoepassing voor meer informatie over installatieprogramma's.

(Optioneel) Opstartparameters instellen

Notitie

Voordat u besluit opstartparameters toe te voegen, moet u nagaan of dit de beste manier is om informatie door te geven aan uw service. Hoewel ze eenvoudig te gebruiken en parseren zijn en een gebruiker ze gemakkelijk kan overschrijven, zijn ze mogelijk moeilijker te vinden en te gebruiken zonder documentatie. Als voor uw service meer dan slechts enkele opstartparameters zijn vereist, moet u in plaats daarvan het register of een configuratiebestand gebruiken.

Een Windows-service kan opdrachtregelargumenten of opstartparameters accepteren. Wanneer u code toevoegt aan opstartparameters voor processen, kan een gebruiker uw service starten met eigen aangepaste opstartparameters in het venster met service-eigenschappen. Deze opstartparameters blijven echter niet behouden wanneer de service de volgende keer wordt gestart. Als u opstartparameters permanent wilt instellen, stelt u deze in het register in.

Elke Windows-service heeft een registervermelding onder de subsleutelHKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services . Gebruik onder de subsleutel van elke service de subsleutel Parameters om informatie op te slaan waartoe uw service toegang heeft. U kunt toepassingsconfiguratiebestanden voor een Windows-service op dezelfde manier gebruiken als voor andere typen programma's. Zie voor voorbeeldcode ConfigurationManager.AppSettings.

Opstartparameters toevoegen

Selecteer Program.cs of MyNewService.Designer. vb en kies vervolgens Code weergeven in het snelmenu. Wijzig in de Main methode de code om een invoerparameter toe te voegen en geef deze door aan de serviceconstructor:

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

Wijzig in MyNewService.cs of MyNewService.vb de MyNewService constructor om de invoerparameter als volgt te verwerken:

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

Met deze code wordt de naam van de gebeurtenisbron en het logboek ingesteld op basis van de opstartparameters die de gebruiker levert. Als er geen argumenten worden opgegeven, worden standaardwaarden gebruikt.

Als u de opdrachtregelargumenten wilt opgeven, voegt u de volgende code toe aan de ProjectInstaller klasse in ProjectInstaller.cs of 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
```
Deze waarde bevat doorgaans het volledige pad naar het uitvoerbare bestand voor de Windows-service. Om de service correct te starten, moet de gebruiker aanhalingstekens opgeven voor het pad en elke afzonderlijke parameter. Een gebruiker kan de parameters in de registervermelding ImagePath wijzigen om de opstartparameters voor de Windows-service te wijzigen. Een betere manier is echter om de waarde programmatisch te wijzigen en de functionaliteit op een gebruiksvriendelijke manier beschikbaar te maken, bijvoorbeeld met behulp van een beheer- of configuratiehulpprogramma.

De service bouwen

Kies in Solution ExplorerEigenschappen in het snelmenu voor het project MyNewService .

De eigenschappenpagina's voor uw project worden weergegeven.
Kies op het tabblad Toepassing in de lijst Opstartobject de optie MyNewService.Program of Sub Main voor Visual Basic-projecten.
Als u het project wilt bouwen, kiest u in Solution ExplorerDe optie Bouwen in het snelmenu voor uw project (of drukt u op Ctrl+Shift+B).

De service installeren

Nu u de Windows-service hebt gebouwd, kunt u deze installeren. Als u een Windows-service wilt installeren, moet u beschikken over beheerdersreferenties op de computer waarop deze is geïnstalleerd.

Open Opdrachtprompt voor ontwikkelaars voor Visual Studio met beheerdersreferenties.
Navigeer in opdrachtprompt voor ontwikkelaars voor Visual Studio naar de map met de uitvoer van uw project (standaard de submap \bin\Debug van uw project).
Voer de volgende opdracht in:
```
installutil MyNewService.exe
```
Als de service is geïnstalleerd, meldt de opdracht geslaagd.

Als het systeem installutil.exeniet kan vinden, controleert u of deze bestaat op uw computer. Dit hulpprogramma wordt geïnstalleerd met de .NET Framework in de map %windir%\Microsoft.NET\Framework[64]\<framework-versie>. Het standaardpad voor de 64-bits versie is bijvoorbeeld %windir%\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe.

Als het installutil.exe proces mislukt, controleert u het installatielogboek om erachter te komen waarom. Het logboek bevindt zich standaard in dezelfde map als het uitvoerbare bestand van de service. De installatie kan mislukken als:
- De RunInstallerAttribute klas is niet aanwezig in de ProjectInstaller klas.
- Het kenmerk is niet ingesteld op true.
- De ProjectInstaller klasse is niet gedefinieerd als public.

Zie Instructies: Services installeren en verwijderen voor meer informatie.

De service starten en uitvoeren

Open in Windows de bureaublad-app Services . Druk op Windows+R om het vak Uitvoeren te openen, voer services.msc in en druk vervolgens op Enter of selecteer OK.

Uw service wordt nu weergegeven in Services, alfabetisch weergegeven met de weergavenaam die u hiervoor hebt ingesteld.
Als u de service wilt starten, kiest u Start in het snelmenu van de service.
Als u de service wilt stoppen, kiest u Stoppen in het snelmenu van de service.
(Optioneel) Gebruik vanaf de opdrachtregel de opdrachten net start <service name> en net stop <service name> om uw service te starten en te stoppen.

De uitvoer van het gebeurtenislogboek van uw service controleren

Open in Windows de Logboeken bureaublad-app. Voer Logboeken in de zoekbalk van Windows in en selecteer vervolgens Logboeken in de zoekresultaten.

Tip

In Visual Studio kunt u gebeurtenislogboeken openen door Server Explorer te openen vanuit het menu Weergave (of druk op Ctrl+Alt+S) en het knooppunt Gebeurtenislogboeken voor de lokale computer uit te vouwen.
Vouw in LogboekenLogboeken toepassingen en services uit.
Zoek de vermelding voor MyNewLog (of MyLogFile1 als u de procedure voor het toevoegen van opdrachtregelargumenten hebt gevolgd) en vouw deze uit. U ziet nu de vermeldingen voor de twee acties (starten en stoppen) die uw service heeft uitgevoerd.

Resources opschonen

Als u de Windows-service-app niet meer nodig hebt, kunt u deze verwijderen.

Open Opdrachtprompt voor ontwikkelaars voor Visual Studio met beheerdersreferenties.
Navigeer in het venster Opdrachtprompt voor ontwikkelaars voor Visual Studio naar de map met de uitvoer van uw project.
Voer de volgende opdracht in:
```
installutil.exe /u MyNewService.exe
```
Als de service is verwijderd, meldt de opdracht dat uw service is verwijderd. Zie Instructies: Services installeren en verwijderen voor meer informatie.

Volgende stappen

Nu u de service hebt gemaakt, kunt u het volgende doen:

Maak een zelfstandig installatieprogramma dat anderen kunnen gebruiken om uw Windows-service te installeren. Gebruik de WiX Toolset om een installatieprogramma voor een Windows-service te maken. Zie Een installatiepakket maken voor andere ideeën.
Verken het ServiceController onderdeel, waarmee u opdrachten kunt verzenden naar de service die u hebt geïnstalleerd.
In plaats van het gebeurtenislogboek te maken wanneer de toepassing wordt uitgevoerd, gebruikt u een installatieprogramma om een gebeurtenislogboek te maken wanneer u de toepassing installeert. Het gebeurtenislogboek wordt verwijderd door het installatieprogramma wanneer u de toepassing verwijdert. Voor meer informatie raadpleegt u EventLogInstaller.

Delen via