Hosting .NET Core Applications as Windows Services

.NET Core is a powerful, cross-platform framework that enables developers to build high-performance applications. While .NET Core applications are typically executed in development environments or as console applications, you may want to run your application as a Windows Service for production environments. Running an application as a Windows Service provides several advantages, such as automatic startup, background execution, and easier management.

In this blog post, we will walk through the steps to run a .NET Core application as a Windows Service, including setting up your project and configuring it for service management.

Prerequisites

Before we begin, make sure you have the following:

1. Windows Operating System – The steps below are specifically for Windows environments.
2. .NET Core SDK – Download and install the .NET Core SDK if you haven't already.
3. Visual Studio or Visual Studio Code – You'll need an IDE to write and run your application.
4. Administrator Privileges – Setting up and managing Windows Services requires administrator access.

Step 1: Create a New .NET Core Worker Service

.NET Core provides a built-in template to create Worker Services that are designed to run in the background as Windows Services. To create a new Worker Service:

1. Open your terminal (Command Prompt or PowerShell) and run the following command:

   dotnet new worker -n MyWindowsService

2. Navigate into the project directory:

   cd MyWindowsService

Step 2: Add Required Packages

To enable the app to run as a Windows Service, install the following NuGet package:

dotnet add package Microsoft.Extensions.Hosting.WindowsServices

Step 3: Modify Program.cs

Edit

Program.cs

to detect if the app is running as a Windows Service and configure the host accordingly:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System.Diagnostics;
using System.IO;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);

builder.Services.AddHostedService<Worker>();

if (OperatingSystem.IsWindows())
{
    builder.Host.UseWindowsService();
}

var app = builder.Build();
app.Run();

Step 4: Build and Publish

Now publish the application as a folder-deployable app:

dotnet publish -c Release -o C:\Services\MyWindowsService

Step 5: Create the Windows Service

Use the

sc.exe

tool to create the service from an elevated command prompt:

sc create MyWindowsService binPath= "C:\Services\MyWindowsService\MyWindowsService.exe"

Then start the service:

sc start MyWindowsService

Step 6: Debugging and Logging

When running as a Windows Service, standard console logs won’t appear. You should configure a file-based logger or use Windows Event Logs to capture logs.

Step 7: Stop and Delete the Service

To stop and remove the service when no longer needed:

sc stop MyWindowsService
sc delete MyWindowsService

Benefits of Running as a Windows Service

• Automatic Startup: Services start with the system.
• Stability: Runs in the background without user login.
• Monitoring: Manage easily via Windows Services UI or PowerShell.
• Resilience: Can be configured to restart on failure.

Conclusion

Running a .NET Core Worker Service as a Windows Service is a reliable and production-ready solution for background tasks, scheduled jobs, or daemon-style operations. With just a few modifications and configurations, your app can seamlessly integrate into Windows service infrastructure.

In future articles, we’ll explore how to add logging, health checks, and service recovery options to further improve your background services.