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 to create a new Worker project:

   dotnet new worker -n MyWindowsService
   <span class="hljs-built_in">cd</span> MyWindowsService
   

   This command will generate a new Worker Service project with the necessary setup to run as a Windows Service.

Step 2: Modify the Worker Service

Inside the 

Worker

 class, you’ll find an example 

ExecuteAsync

 method that runs in the background when the service starts. You can modify this method to include the logic of your application.

For instance, if you're running a background task, you can modify the 

ExecuteAsync

 method as follows:

csharp
Copy code
<span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">Worker</span> : <span class="hljs-title">BackgroundService</span>
{
    <span class="hljs-keyword">private</span> <span class="hljs-keyword">readonly</span> ILogger&lt;Worker&gt; _logger;

    <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-title">Worker</span>(<span class="hljs-params">ILogger&lt;Worker&gt; logger</span>)</span>
    {
        _logger = logger;
    }

    <span class="hljs-function"><span class="hljs-keyword">protected</span> <span class="hljs-keyword">override</span> <span class="hljs-keyword">async</span> Task <span class="hljs-title">ExecuteAsync</span>(<span class="hljs-params">CancellationToken stoppingToken</span>)</span>
    {
        <span class="hljs-keyword">while</span> (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation(<span class="hljs-string">"Worker running at: {time}"</span>, DateTimeOffset.Now);
            <span class="hljs-keyword">await</span> Task.Delay(<span class="hljs-number">1000</span>, stoppingToken);
        }
    }
}

Step 3: Add the Windows Service Hosting

To run the application as a Windows Service, you need to modify the 

Program.cs

 file to include the 

UseWindowsService

 method. This will configure the worker to run as a Windows Service when deployed to a Windows machine.

Modify 

Program.cs

 as follows:

csharp
Copy code
<span class="hljs-keyword">using</span> Microsoft.Extensions.DependencyInjection;
<span class="hljs-keyword">using</span> Microsoft.Extensions.Hosting;

<span class="hljs-keyword">namespace</span> <span class="hljs-title">MyWindowsService</span>
{
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">class</span> <span class="hljs-title">Program</span>
    {
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title">Main</span>(<span class="hljs-params"><span class="hljs-built_in">string</span>[] args</span>)</span>
        {
            CreateHostBuilder(args).Build().Run();
        }

        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> IHostBuilder <span class="hljs-title">CreateHostBuilder</span>(<span class="hljs-params"><span class="hljs-built_in">string</span>[] args</span>)</span> =&gt;
            Host.CreateDefaultBuilder(args)
                .ConfigureServices((hostContext, services) =&gt;
                {
                    services.AddHostedService&lt;Worker&gt;();
                })
                .UseWindowsService(); <span class="hljs-comment">// Add this line to run as a Windows Service</span>
    }
}

Step 4: Publish the Application

To deploy your Worker Service, you need to publish it to a folder. Run the following command in your project directory:

bash
Copy code
dotnet publish -c Release -r win-x64 --self-contained

This command will generate a self-contained executable that can run on any Windows machine without requiring the .NET runtime to be installed.

Step 5: Install and Run the Service

To install your application as a Windows Service, you’ll need to use the 

sc

 command or create a service configuration script using PowerShell.

Here’s how to install the service using the 

sc

 command:

1. Open a PowerShell window as Administrator.

2. Run the following command to create the service:

   bash
   Copy code
   sc create MyWindowsService binPath= <span class="hljs-string">"C:\path\to\your\published\app\MyWindowsService.exe"</span>
   

   Make sure to replace 

   "C:\path\to\your\published\app\MyWindowsService.exe"

    with the actual path to your published application.

3. To start the service:

   bash
   Copy code
   sc start MyWindowsService
   

4. To stop the service:

   bash
   Copy code
   sc stop MyWindowsService
   

5. To remove the service:

   bash
   Copy code
   sc delete MyWindowsService
   

Step 6: Verify Service Operation

Once the service is installed, you can verify that it’s running by checking the Windows Service Manager or by using the 

sc query

 command:

bash
Copy code
sc query MyWindowsService

You should see the status of the service, and it should be running. Additionally, you can check the logs created by your Worker Service, as configured by the 

ILogger

 service.

Conclusion

Running a .NET Core application as a Windows Service provides a robust and reliable way to manage long-running background processes. By following the steps above, you can create, deploy, and manage your application as a service on Windows, making it easier to handle tasks like auto-starting on boot and running without a user interface.

As always, consider testing your services thoroughly and managing their lifecycle properly for production environments. With .NET Core's flexibility, you can create powerful background applications that seamlessly integrate into the Windows ecosystem.