Självstudie: Skapa en Windows-tjänstapp

Artikel
04/08/2023

Varning

Den här dokumentationen gäller inte för den senaste versionen av Windows-tjänsten. Det senaste innehållet i Windows Services med hjälp av BackgroundService och arbetstjänstmallen finns i:

Den här artikeln visar hur du skapar en Windows-tjänstapp i Visual Studio som skriver meddelanden till en händelselogg.

Skapa en tjänst

Börja genom att skapa projektet och ange de värden som krävs för att tjänsten ska fungera korrekt.

På Menyn Visual Studio-fil väljer du Nytt>projekt (eller trycker på Ctrl+Skift+N) för att öppna fönstret Nytt projekt .
Leta upp och välj projektmallen Windows Service (.NET Framework).

Anteckning

Om du inte ser Windows-tjänstmallen kan du behöva installera arbetsbelastningen .NET Desktop Development med hjälp av Visual Studio Installer.
För Namn anger du MyNewService och väljer sedan OK.

Fliken Design visas (Service1.cs [Design] eller Service1.vb [Design]).

Projektmallen innehåller en komponentklass med namnet Service1 som ärver från System.ServiceProcess.ServiceBase. Den innehåller mycket av den grundläggande tjänstkoden, till exempel koden för att starta tjänsten.

Byt namn på tjänsten

Byt namn på tjänsten från Service1 till MyNewService.

I Solution Explorer väljer du Service1.cs eller Service1.vb och sedan Byt namn på snabbmenyn. Byt namn på filen till MyNewService.cs eller MyNewService.vb och tryck sedan på Retur

Ett popup-fönster visas som frågar om du vill byta namn på alla referenser till kodelementet Service1.
I popup-fönstret väljer du Ja.
På fliken Design väljer du Egenskaper på snabbmenyn. I fönstret Egenskaper ändrar du värdet för ServiceName till MyNewService.
Välj Spara alla på Arkiv-menyn .

Lägga till funktioner i tjänsten

I det här avsnittet lägger du till en anpassad händelselogg i Windows-tjänsten. Komponenten EventLog är ett exempel på den typ av komponent som du kan lägga till i en Windows-tjänst.

Lägga till anpassade händelseloggfunktioner

I Solution Explorer går du till snabbmenyn för MyNewService.cs eller MyNewService.vb och väljer Visa Designer.
I Verktygslåda expanderar du Komponenter och drar sedan komponenten EventLog till fliken Service1.cs [Design] eller Service1.vb [Design].
I Solution Explorer går du till snabbmenyn för MyNewService.cs eller MyNewService.vb och väljer Visa kod.

Definiera en anpassad händelselogg.

För C# redigerar du den befintliga MyNewService() konstruktorn enligt följande kodfragment. För Visual Basic lägger du till New() konstruktorn enligt följande kodfragment.

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

Lägg till en using -instruktion i MyNewService.cs (om den inte redan finns) eller en Imports -instruktion i MyNewService.vb för System.Diagnostics namnområdet:
```
using System.Diagnostics;
```
```
Imports System.Diagnostics
```
Välj Spara alla på Arkiv-menyn .

Definiera vad som händer när tjänsten startar

Leta upp OnStart metoden i kodredigeraren för MyNewService.cs eller MyNewService.vb. Visual Studio skapade automatiskt en tom metoddefinition när du skapade projektet. Lägg till kod som skriver en post i händelseloggen när tjänsten startar:

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

Avsökning

Eftersom ett tjänstprogram är utformat för att vara långvarigt avsöker eller övervakar det vanligtvis systemet som du har konfigurerat i OnStart metoden . Metoden OnStart måste återgå till operativsystemet när tjänstens åtgärd har påbörjats så att systemet inte blockeras.

Om du vill konfigurera en enkel avsökningsmekanism använder du komponenten System.Timers.Timer . Timern genererar en Elapsed händelse med jämna mellanrum, då tjänsten kan övervaka den. Du använder komponenten på Timer följande sätt:

Ange egenskaperna för komponenten TimerMyNewService.OnStart i metoden .
Starta timern genom att anropa Start metoden .

Konfigurera avsökningsmekanismen

Lägg till en using -instruktion i MyNewService.cs, eller en Imports -instruktion i MyNewService.vb, för System.Timers namnområdet:
```
using System.Timers;
```
```
Imports System.Timers
```

Lägg till följande kod i MyNewService.OnStart händelsen för att konfigurera avsökningsmekanismen:

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

MyNewService Lägg till en medlemsvariabel i klassen . Den innehåller identifieraren för nästa händelse för att skriva till händelseloggen:
```
private int eventId = 1;
```
```
Private eventId As Integer = 1
```

MyNewService I klassen lägger du till OnTimer metoden för att hantera Timer.Elapsed händelsen:

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

I stället för att köra allt arbete i huvudtråden kan du köra uppgifter med hjälp av bakgrundsarbetstrådar. Mer information finns i System.ComponentModel.BackgroundWorker.

Definiera vad som händer när tjänsten stoppas

Infoga en kodrad i metoden som lägger till en post i OnStop händelseloggen när tjänsten stoppas:

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

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

Definiera andra åtgärder för tjänsten

Du kan åsidosätta OnPausemetoderna , OnContinueoch OnShutdown för att definiera ytterligare bearbetning för din komponent.

Följande kod visar hur du kan åsidosätta OnContinue metoden i MyNewService klassen :

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

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

Ange tjänststatus

Tjänster rapporterar sin status till Service Control Manager så att en användare kan se om en tjänst fungerar korrekt. Som standard rapporterar en tjänst som ärver från ServiceBase en begränsad uppsättning statusinställningar, som omfattar SERVICE_STOPPED, SERVICE_PAUSED och SERVICE_RUNNING. Om det tar en stund att starta en tjänst är det bra att rapportera en SERVICE_START_PENDING status.

Du kan implementera statusinställningarna för SERVICE_START_PENDING och SERVICE_STOP_PENDING genom att lägga till kod som anropar funktionen Windows SetServiceStatus .

Implementera väntande status för tjänsten

Lägg till en using -instruktion i MyNewService.cs, eller en Imports -instruktion i MyNewService.vb, för System.Runtime.InteropServices namnområdet:
```
using System.Runtime.InteropServices;
```
```
Imports System.Runtime.InteropServices
```

Lägg till följande kod i MyNewService.cs, eller MyNewService.vb, för att deklarera ServiceState värdena och lägga till en struktur för statusen, som du ska använda i ett plattformsanrop:

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

Anteckning

Service Control Manager använder dwWaitHint medlemmarna och dwCheckpoint i SERVICE_STATUS-strukturen för att avgöra hur lång tid det tar att vänta tills en Windows-tjänst startas eller stängs av. Om metoderna OnStart och OnStop körs länge kan tjänsten begära mer tid genom att anropa SetServiceStatus igen med ett inkrementerat dwCheckPoint värde.

MyNewService I klassen deklarerar du funktionen SetServiceStatus med hjälp av plattformsanrop:

[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

Om du vill implementera statusen SERVICE_START_PENDING lägger du till följande kod i OnStart början av metoden:

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

Lägg till kod i slutet av OnStart metoden för att ange statusen till 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)

(Valfritt) Om OnStop är en långvarig metod upprepar du den här proceduren OnStop i -metoden. Implementera statusen SERVICE_STOP_PENDING och returnera SERVICE_STOPPED status innan OnStop metoden avslutas.

Exempel:

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

Lägga till installationsprogram i tjänsten

Innan du kör en Windows-tjänst måste du installera den, som registrerar den med Service Control Manager. Lägg till installationsprogram i projektet för att hantera registreringsinformationen.

I Solution Explorer går du till snabbmenyn för MyNewService.cs eller MyNewService.vb och väljer Visa Designer.
I vyn Design väljer du bakgrundsområdet och väljer sedan Lägg till installationsprogram på snabbmenyn.

Som standard lägger Visual Studio till en komponentklass med namnet ProjectInstaller, som innehåller två installationsprogram, i projektet. Dessa installationsprogram är för din tjänst och för tjänstens associerade process.
I designvyn för ProjectInstaller väljer du serviceInstaller1 för ett Visual C#-projekt eller ServiceInstaller1 för ett Visual Basic-projekt och väljer sedan Egenskaper på snabbmenyn.
I fönstret Egenskaper kontrollerar du att ServiceName egenskapen är inställd på MyNewService.
Lägg till text i Description egenskapen, till exempel En exempeltjänst.

Den här texten visas i kolumnen Beskrivning i fönstret Tjänster och beskriver tjänsten för användaren.
Lägg till text i DisplayName egenskapen . Till exempel Visningsnamn för MyNewService.

Den här texten visas i kolumnen Visningsnamn i fönstret Tjänster . Det här namnet kan skilja sig från ServiceName egenskapen , vilket är det namn som systemet använder (till exempel namnet som du använder för kommandot för net start att starta tjänsten).
Ange egenskapen StartType till Automatic från listrutan.
När du är klar bör egenskapsfönstren se ut som på följande bild:
I designvyn för ProjectInstaller väljer du serviceProcessInstaller1 för ett Visual C#-projekt eller ServiceProcessInstaller1 för ett Visual Basic-projekt och väljer sedan Egenskaper på snabbmenyn. Ange egenskapen Account till LocalSystem från listrutan.

Den här inställningen installerar tjänsten och kör den med hjälp av det lokala systemkontot.

Viktigt

Kontot LocalSystem har breda behörigheter, inklusive möjligheten att skriva till händelseloggen. Använd det här kontot med försiktighet eftersom det kan öka risken för attacker från skadlig programvara. För andra uppgifter bör du överväga att använda LocalService kontot, som fungerar som en icke-privilegierad användare på den lokala datorn och presenterar anonyma autentiseringsuppgifter för alla fjärrservrar. Det här exemplet misslyckas om du försöker använda LocalService kontot eftersom det behöver behörighet att skriva till händelseloggen.

Mer information om installationsprogram finns i Så här lägger du till installationsprogram i tjänstprogrammet.

(Valfritt) Ange startparametrar

Anteckning

Innan du bestämmer dig för att lägga till startparametrar bör du överväga om det är det bästa sättet att skicka information till din tjänst. Även om de är enkla att använda och parsa, och en användare enkelt kan åsidosätta dem, kan det vara svårare för en användare att identifiera och använda utan dokumentation. Om tjänsten kräver mer än bara några få startparametrar bör du i stället använda registret eller en konfigurationsfil.

En Windows-tjänst kan acceptera kommandoradsargument eller startparametrar. När du lägger till kod för att bearbeta startparametrar kan en användare starta tjänsten med sina egna anpassade startparametrar i fönstret tjänstegenskaper. Dessa startparametrar sparas dock inte nästa gång tjänsten startas. Ange startparametrarna permanent genom att ange dem i registret.

Varje Windows-tjänst har en registerpost under HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services undernyckel. Under varje tjänsts undernyckel använder du undernyckeln Parametrar för att lagra information som din tjänst kan komma åt. Du kan använda programkonfigurationsfiler för en Windows-tjänst på samma sätt som för andra typer av program. Exempelkod finns i ConfigurationManager.AppSettings.

Lägga till startparametrar

Välj Program.cs eller MyNewService.Designer. vb och välj sedan Visa kod på snabbmenyn. Main I metoden ändrar du koden för att lägga till en indataparameter och skicka den till tjänstkonstruktorn:

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

I MyNewService.cs eller MyNewService.vb ändrar du MyNewService konstruktorn så att indataparametern bearbetas på följande sätt:

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

Den här koden anger händelsekällan och loggnamnet enligt de startparametrar som användaren tillhandahåller. Om inga argument anges används standardvärden.

Om du vill ange kommandoradsargumenten lägger du till ProjectInstaller följande kod i klassen i ProjectInstaller.cs eller 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
```
Vanligtvis innehåller det här värdet den fullständiga sökvägen till den körbara filen för Windows-tjänsten. För att tjänsten ska kunna startas korrekt måste användaren ange citattecken för sökvägen och varje enskild parameter. En användare kan ändra parametrarna i ImagePath-registerposten för att ändra startparametrarna för Windows-tjänsten. Ett bättre sätt är dock att ändra värdet programmatiskt och exponera funktionerna på ett användarvänligt sätt, till exempel genom att använda ett hanterings- eller konfigurationsverktyg.

Skapa tjänsten

I Solution Explorer väljer du Egenskaper på snabbmenyn för projektet MyNewService .

Egenskapssidorna för projektet visas.
På fliken Program går du till listan Startobjekt och väljer MyNewService.Program eller Sub Main för Visual Basic-projekt.
Om du vill skapa projektet går du till Solution Explorer och väljer Skapa på snabbmenyn för projektet (eller trycker på Ctrl+Skift+B).

Installera tjänsten

Nu när du har skapat Windows-tjänsten kan du installera den. Om du vill installera en Windows-tjänst måste du ha administratörsautentiseringsuppgifter på den dator där den är installerad.

Öppna Kommandotolken för utvecklare för Visual Studio med administrativa autentiseringsuppgifter.
I kommandotolken för utvecklare för Visual Studio navigerar du till mappen som innehåller projektets utdata (som standard underkatalogen \bin\Debug för projektet).
Ange följande kommando:
```
installutil MyNewService.exe
```
Om tjänsten har installerats rapporterar kommandot att åtgärden lyckades.

Om systemet inte hittar installutil.exekontrollerar du att det finns på datorn. Det här verktyget installeras med .NET Framework till mappen %windir%\Microsoft.NET\Framework[64]\<framework version>. Standardsökvägen för 64-bitarsversionen är till exempel %windir%\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe.

Om installutil.exe processen misslyckas kontrollerar du installationsloggen för att ta reda på varför. Som standard finns loggen i samma mapp som den körbara tjänsten. Installationen kan misslyckas om:
- Klassen RunInstallerAttribute finns inte i ProjectInstaller klassen .
- Attributet är inte inställt på true.
- Klassen ProjectInstaller definieras inte som public.

Mer information finns i Anvisningar: Installera och avinstallera tjänster.

Starta och köra tjänsten

Öppna skrivbordsappen Tjänster i Windows. Tryck på Windows+R för att öppna rutan Kör , ange services.msc och tryck sedan på Retur eller välj OK.

Du bör se din tjänst i Tjänst, som visas alfabetiskt med det visningsnamn som du har angett för den.
Starta tjänsten genom att välja Starta på tjänstens snabbmeny.
Om du vill stoppa tjänsten väljer du Stoppa från tjänstens snabbmeny.
(Valfritt) Från kommandoraden använder du kommandona net start <service name> och net stop <service name> för att starta och stoppa tjänsten.

Kontrollera utdata från händelseloggen för din tjänst

Öppna Loggboken skrivbordsappen i Windows. Ange Loggboken i sökfältet i Windows och välj sedan Loggboken i sökresultatet.

Tips

I Visual Studio kan du komma åt händelseloggar genom att öppna Server Explorer från Visa-menyn (eller trycka på Ctrl+Alt+S) och expandera noden Händelseloggar för den lokala datorn.
I Loggboken expanderar du Program- och tjänstloggar.
Leta upp listan för MyNewLog (eller MyLogFile1 om du följde proceduren för att lägga till kommandoradsargument) och expandera den. Du bör se posterna för de två åtgärderna (starta och stoppa) som din tjänst utförde.

Rensa resurser

Om du inte längre behöver Windows-tjänstappen kan du ta bort den.

Öppna Kommandotolken för utvecklare för Visual Studio med administrativa autentiseringsuppgifter.
I fönstret Developer Command Prompt for Visual Studio (Kommandotolk för utvecklare för Visual Studio ) navigerar du till mappen som innehåller projektets utdata.
Ange följande kommando:
```
installutil.exe /u MyNewService.exe
```
Om tjänsten avinstalleras rapporterar kommandot att tjänsten har tagits bort. Mer information finns i Anvisningar: Installera och avinstallera tjänster.

Nästa steg

Nu när du har skapat tjänsten kan du:

Skapa ett fristående installationsprogram som andra kan använda för att installera Windows-tjänsten. Använd WiX-verktygsuppsättningen för att skapa ett installationsprogram för en Windows-tjänst. Andra idéer finns i Skapa ett installationspaket.
Utforska komponenten ServiceController , som gör att du kan skicka kommandon till den tjänst som du har installerat.
I stället för att skapa händelseloggen när programmet körs använder du ett installationsprogram för att skapa en händelselogg när du installerar programmet. Händelseloggen tas bort av installationsprogrammet när du avinstallerar programmet. Mer information finns i EventLogInstaller.

Dela via