How to Create a Windows Service Using C# (Step-by-Step)

Windows Services are background applications that run without UI and start automatically with Windows. They are ideal for:

? Scheduled tasks
? File monitoring
? Background processing
? Automation jobs
? Queue listeners

Step 1: Create the Windows Service Project

In Visual Studio:

1. Open Visual Studio

2. Click Create a new project

3. Search for Windows Service (.NET Framework)
   (Use .NET Framework version 4.7.2+)

4. Give it a name ? e.g., MyWindowsService

5. Click Create

You will see a class called:

public partial class Service1 : ServiceBase

Step 2: Write Service Code

Open Service1.cs ? write logic inside OnStart and OnStop.

public partial class Service1 : ServiceBase
{
    private System.Timers.Timer timer;

    public Service1()
    {
        InitializeComponent();
    }

    protected override void OnStart(string[] args)
    {
        timer = new System.Timers.Timer();
        timer.Interval = 5000; // runs every 5 seconds
        timer.Elapsed += Timer_Elapsed;
        timer.Start();
    }

    private void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
        WriteLog("Service is running at: " + DateTime.Now);
    }

    protected override void OnStop()
    {
        WriteLog("Service stopped.");
    }

    private void WriteLog(string message)
    {
        string path = @"C:\MyServiceLog.txt";
        File.AppendAllText(path, message + Environment.NewLine);
    }
}

Step 3: Add Installer (Required!)

Right-click inside Service1.cs ? Add Installer

It will generate two components:

? ServiceProcessInstaller
? ServiceInstaller

Set properties:

ServiceProcessInstaller

Account = System.ServiceProcess.ServiceAccount.LocalSystem;

ServiceInstaller

ServiceName = "MyWindowsService";
StartType = Automatic;

Step 4: Build the Project

Go to:

Build ? Build Solution

It creates .exe inside:

bin\Release\

Step 5: Install the Service (Windows CMD)

Open Command Prompt as Administrator.

Run:

sc create MyWindowsService binPath= "C:\Path\To\MyWindowsService.exe"

Start the service:

sc start MyWindowsService

Stop the service:

sc stop MyWindowsService

Delete service:

sc delete MyWindowsService

Alternative Installation (PowerShell)

New-Service -Name "MyWindowsService" -BinaryPathName "C:\Path\MyWindowsService.exe"
Start-Service MyWindowsService

Step 6: Debugging Windows Service

Windows services cannot run by double-click.
To debug:

Option 1 — Temporary Console Mode

Add this code:

#if DEBUG
System.Threading.Thread.Sleep(10000);
#endif

Or create a console runner.

Option 2 — Attach to Process

1. Install service

2. Start service

3. In Visual Studio ? Debug ? Attach to Process

4. Select your service EXE

5. Add breakpoints ? Debug

Top Use Cases

Creating a Windows Service in C# is easier than it looks.
You mainly need two things:

1. A service class that inherits from ServiceBase

2. A service installer (or use PowerShell to install)

Step-by-Step (Modern .NET 6/7/8 Way)

This is the recommended method — no need for old ServiceBase boilerplate.

1.Create a Worker Service Project

In Visual Studio:

File -> New -> Project -> Worker Service

This template is made for Windows Services.

2. Add the Windows Service Host

In Program.cs:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

Host.CreateDefaultBuilder(args)
    .UseWindowsService()         //  Makes it run as a real Windows Service
    .ConfigureServices(services =>
    {
        services.AddHostedService();
    })
    .Build()
    .Run();

3. Add Your Service Logic

Worker.cs:

public class Worker : BackgroundService
{
    private readonly ILogger _logger;

    public Worker(ILogger logger)
    {
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogInformation("Service running at {time}", DateTime.Now);
            await Task.Delay(5000, stoppingToken);
        }
    }
}

4. Publish the service

dotnet publish -c Release

5. Install the service (PowerShell)

Run PowerShell as Administrator:

New-Service -Name "MyWindowsService" `
            -BinaryPathName "C:\Path\To\publish\MyService.exe" `
            -StartupType Automatic

Start it:

Start-Service MyWindowsService

Check status:

Get-Service MyWindowsService

In One Line:

Create a Worker Service ? Call .UseWindowsService() ? Publish ? Install via PowerShell ? Done.

Refer the following articles which have described each and everything in detailed step by step:

• Creating a Windows Service in C#

• Create a Windows Service in C#

• Create A Windows Service In C#

Step 1: Create a new project

1. Open Visual Studio ? Create a new project.

2. Select Windows Service (.NET Framework) (or Worker Service if you use .NET Core/.NET 6+).

3. Name it something like MyWindowsService.

Step 2: Add core service logic

In Service1.cs (or your service class), you’ll see two methods:

protected override void OnStart(string[] args)
{
    // Code that runs when the service starts
    WriteLog("Service started.");
    timer = new System.Timers.Timer();
    timer.Interval = 60000; // Run every 1 minute
    timer.Elapsed += OnElapsedTime;
    timer.Start();
}

protected override void OnStop()
{
    // Code that runs when the service stops
    WriteLog("Service stopped.");
    timer.Stop();
}

And add this helper method:

private System.Timers.Timer timer;

private void OnElapsedTime(object sender, System.Timers.ElapsedEventArgs e)
{
    WriteLog("Service running at " + DateTime.Now.ToString());
}

private void WriteLog(string message)
{
    string path = AppDomain.CurrentDomain.BaseDirectory + "\\Logs";
    if (!Directory.Exists(path))
        Directory.CreateDirectory(path);
    
    string filePath = Path.Combine(path, "ServiceLog.txt");
    File.AppendAllText(filePath, DateTime.Now + " - " + message + Environment.NewLine);
}

This will log timestamps every minute when the service runs.

?? 3. Add Installer (for .NET Framework)

If you’re using .NET Framework (not .NET Core), you need to add an installer.

1. In Service1.cs, right-click ? View Designer.

2. Right-click ? Add Installer.

3. This adds ProjectInstaller.cs with two components:

   • serviceInstaller1

   • serviceProcessInstaller1

Now configure them:

// ProjectInstaller.cs
public ProjectInstaller()
{
    InitializeComponent();

    serviceProcessInstaller1.Account = ServiceAccount.LocalSystem;

    serviceInstaller1.ServiceName = "MyWindowsService";
    serviceInstaller1.DisplayName = "My Windows Background Service";
    serviceInstaller1.Description = "This service logs date-time every minute.";
    serviceInstaller1.StartType = ServiceStartMode.Automatic;
}

?? 4. Build and Install the Service

Option 1: Install using PowerShell (recommended)

1. Build your project ? find the .exe under bin\Release or bin\Debug.

2. Open PowerShell (Admin).

3. Run:

New-Service -Name "MyWindowsService" -BinaryPathName "C:\Path\To\MyWindowsService.exe" -DisplayName "My Windows Background Service" -Description "Logs time every minute" -StartupType Automatic

Then start it:

Start-Service MyWindowsService

Option 2: Use sc.exe

sc create MyWindowsService binPath= "C:\Path\To\MyWindowsService.exe" start= auto
sc start MyWindowsService

?? 5. View Logs & Debugging

Check your log file in the Logs folder created beside your .exe — you should see lines like:

11/06/2025 10:01:00 AM - Service running at 11/06/2025 10:01:00 AM

If not, check the Windows Event Viewer ? Windows Logs ? Application for errors.

?? 6. For .NET Core / .NET 6+

If you're on modern .NET (Core or 6/7/8), use a Worker Service instead.

Create via CLI:

dotnet new worker -n MyWorkerService

Then in Program.cs:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

Host.CreateDefaultBuilder(args)
    .UseWindowsService() // Important for Windows Services
    .ConfigureServices((context, services) =>
    {
        services.AddHostedService();
    })
    .Build()
    .Run();

Your Worker.cs will have:

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    while (!stoppingToken.IsCancellationRequested)
    {
        File.AppendAllText("C:\\Logs\\WorkerLog.txt", $"Running at: {DateTime.Now}\n");
        await Task.Delay(60000, stoppingToken); // Every minute
    }
}

Then publish:

dotnet publish -c Release -r win-x64

And install using:

sc create MyWorkerService binPath= "C:\publish\MyWorkerService.exe"

?? 7. Uninstall the Service

Stop-Service MyWindowsService
Remove-Service MyWindowsService

Steps to Create a Windows Service in C#

Create a new project ? Choose “Windows Service (.NET Framework)”.

Name your project

? e.g. MyFirstWindowsService.

Open Service1.cs

? This is your main service file.

Write your logic

? Use the OnStart() method to start your code.

? Use the OnStop() method to stop it.

Example:

protected override void OnStart(string[] args)

{

File.AppendAllText(@"C:\log.txt", "Service started\n");

}

protected override void OnStop()

{

File.AppendAllText(@"C:\log.txt", "Service stopped\n");

}

Add Installer

? Right-click inside Service1.cs ? Choose “Add Installer”.

? This creates a ProjectInstaller.cs file to help install the service.

Build the project

? This will create an .exe file in your bin/Debug or bin/Release folder.

Install the service

? Open Command Prompt as Administrator.

? Run:

sc create MyService binPath= "C:\Path\To\YourService.exe"

Start the service

net start MyService

Stop or delete later

net stop MyService

sc delete MyService