Självstudie: Skapa en Windows-tjänstapp

Den här artikeln visar hur du skapar en .NET Framework Windows-tjänstapp i Visual Studio. Tjänsten skriver helt enkelt 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.

1. Öppna fönstret Nytt projekt genom att välja Nytt> (eller tryck på Ctrl++) på Menyn Visual Studio-fil.

2. Leta upp och välj projektmallen Windows Service (.NET Framework).

   Anmärkning

   Om du inte ser Windows Service-mallen kan du behöva installera arbetsbelastningen för .NET-skrivbordsutveckling med hjälp av Visual Studio Installer.

3. Som Projektnamn anger du MyNewService och väljer sedan Skapa.

   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.

1. I Solution Explorer väljer du Service1.cs eller Service1.vb och väljer 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.

2. I popup-fönstret väljer du Ja.

   

3. 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å vilken typ av komponent du kan lägga till i en Windows-tjänst.

Lägga till anpassade händelseloggfunktioner

1. I fönstret Verktygslåda expanderar du Komponenter och drar sedan EventLog-komponenten till Service1.cs [Design] eller Service1.vb [Design] designer.

   Tips/Råd

   Om du inte ser fönstret Verktygslåda väljer du Visa>verktygslåda.

2. I Solution Explorer går du till snabbmenyn för MyNewService.cs eller MyNewService.vb och väljer Visa kod.

3. 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 EventLog();
       if (!EventLog.SourceExists("MySource"))
       {
           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
   

4. Om det inte redan finns lägger du till ett using direktiv i MyNewService.cs, eller en Imports instruktion till MyNewService.vb, för System.Diagnostics namnområdet:

   using System.Diagnostics;
   

   Imports System.Diagnostics
   

5. Välj Spara alla på Arkiv-menyn .

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

Leta upp metoden i kodredigeraren för MyNewService.cs eller OnStart. 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

Opinionsundersö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 utföra sin övervakning. Du använder Timer-komponenten på följande sätt:

• Ange egenskaperna för komponenten Timer i MyNewService.OnStart-metoden.
• Starta timern genom att anropa Start metoden.

Konfigurera avsökningsmekanismen

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

   using System.Timers;
   

   Imports System.Timers
   

2. 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
   {
       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 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
   

4. 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, vilka inkluderar 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 SERVICE_START_PENDING statusinställningarna och SERVICE_STOP_PENDING genom att lägga till kod som anropar funktionen Windows SetServiceStatus .

1. Lägg till ett using direktiv 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
   

2. Lägg till följande uppräkning och struktur 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
   

   Anmärkning

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

3. 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
   

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

   // Update the service state to Start Pending.
   ServiceStatus serviceStatus = new ServiceStatus
   {
       dwCurrentState = ServiceState.SERVICE_START_PENDING,
       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. 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)
   

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

   Till exempel:

   // Update the service state to Stop Pending.
   ServiceStatus serviceStatus = new ServiceStatus
   {
       dwCurrentState = ServiceState.SERVICE_STOP_PENDING,
       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.

1. I Solution Explorer går du till snabbmenyn för MyNewService.cs eller MyNewService.vb och väljer Visa designer.

2. 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.

3. I designvyn för ProjectInstaller väljer du serviceInstaller1 för ett C#-projekt eller ServiceInstaller1 för ett Visual Basic-projekt och väljer sedan Egenskaper på snabbmenyn.

4. I fönstret Egenskaper anger du ServiceName egenskapen till MyNewService.

5. Lägg till text i egenskapen Description , 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.

   

6. Lägg till text i egenskapen DisplayName . 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 namnet systemet använder (till exempel namnet som du använder för kommandot för net start att starta tjänsten).

7. Ange egenskapen StartType till Automatic från listrutan.

8. När du är klar bör egenskapsfönstren se ut som följande bild:

   

9. I designvyn för ProjectInstaller väljer du serviceProcessInstaller1 för ett 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 dock 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

En Windows-tjänst kan acceptera kommandoradsargument, även kallade 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 startparametrar 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 tjänsten 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

1. I MyNewService.cs, eller MyNewService.vb, ändrar du konstruktorn så att den MyNewService accepterar och bearbetar en indataparameter:

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

   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 startparametrarna som användaren tillhandahåller. Om inga argument anges används standardvärden.

2. 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
   

3. 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 exekverbara filen för Windows-tjänsten. För att tjänsten ska 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 med hjälp av ett hanterings- eller konfigurationsverktyg.

Skapa tjänsten

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

2. På fliken Program går du till listan Startobjekt och väljer MyNewService.Program (eller Under main för Visual Basic-projekt).

3. 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.

1. Öppna Kommandotolken för utvecklare för Visual Studio med administrativa autentiseringsuppgifter.

2. 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).

3. Ange följande kommando:

   installutil MyNewService.exe
   

   Om tjänsten installeras rapporterar kommandot lyckat.

   Om systemet inte kan hitta installutil.exekontrollerar du att det finns på datorn. Det här verktyget installeras med .NET Framework i mappen %windir%\Microsoft.NET\Framework[64]\<framework version>.

   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.
   • Du har inte öppnat kommandotolken för utvecklare för VS som administratör.

Mer information finns i Så här: Installera och avinstallera tjänster.

Starta och kör tjänsten

1. Öppna skrivbordsappen Services 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änster, som visas alfabetiskt med det visningsnamn som du har angett för den.

   

2. Starta tjänsten genom att välja Starta från tjänstens snabbmeny.

3. Om du vill stoppa tjänsten väljer du Stoppa från tjänstens snabbmeny.

4. (Valfritt) Från kommandoraden använder du kommandot net start <service name> och net stop <service name> för att starta och stoppa tjänsten.

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

1. Öppna skrivbordsappen Loggboken i Windows: Ange Loggboken i Sökfältet i Windows och välj sedan Loggboken i sökresultaten.

   Tips/Råd

   I Visual Studio kan du komma åt händelseloggar genom att öppna Server Explorer från menyn Visa (eller trycka på Ctrl+Alt+S) och expandera noden Händelseloggar för den lokala datorn.

2. I Händelselogg expandera Program- och tjänstloggar.

3. 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 loggposterna för de två åtgärderna (start och stopp) som din tjänst utförde.

   

Rensa resurser

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

1. Öppna Kommandotolken för utvecklare för Visual Studio med administrativa autentiseringsuppgifter.

2. I fönstret Developer Command Prompt for Visual Studio (Kommandotolken för utvecklare för Visual Studio ) går du till mappen som innehåller projektets körbara fil.

3. 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 Så här: 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.

Se även

• Windows-tjänstprogram
• Introduktion till Windows-tjänstprogram
• Anvisningar: Felsöka Windows-tjänstprogram
• Tjänster (Windows)