Writing Windows services is an important skill for any .NET developer to learn. Services allow you to run long-running background processes and other types of tasks that do not require user interaction. In this article, we will explore how to create a basic Windows service using C# and the .NET framework.
To get started, open up a new Visual Studio project and select the “Windows Service” project template under Visual C# -> Windows Desktop. This will generate a basic service project structure for us to build upon.
The main class for our service will inherit from System.ServiceProcess.ServiceBase. This base class provides all the plumbing needed to install, start, stop and run a service. Let’s rename our main class to MyFirstService:
csharp
Copy
public partial class MyFirstService : ServiceBase
{
}
Inside this class we will override two key methods – OnStart and OnStop. These methods define what our service does when it starts and stops.
In the OnStart method we will add some basic logging to indicate that the service has started:
csharp
Copy
protected override void OnStart(string[] args)
{
Log(“MyFirstService started at ” + DateTime.Now);
}
Similarly in OnStop we will log that the service is stopping:
csharp
Copy
protected override void OnStop()
{
Log(“MyFirstService stopping at ” + DateTime.Now);
}
To log messages from our service we need a way to write to the event log. Let’s add a helper method to do this:
csharp
Copy
private static void Log(string message)
{
EventLog log = new EventLog();
log.Source = “MyFirstService”;
log.WriteEntry(message);
}
This uses the System.Diagnostics.EventLog class to write entries to the Windows Event Log under the source “MyFirstService”.
Now that we have the basic service scaffolding, we can add some actual work for it to perform. For example, we may want it to process files in a watched folder or periodically sync data with a backend service.
Let’s have our service enumerate the running processes every 30 seconds:
csharp
Copy
protected override void OnStart(string[] args)
{
Log(“MyFirstService started”);
Timer timer = new Timer(CheckProcesses, null, 0, 30000);
}
private void CheckProcesses(object state)
{
Process[] processes = Process.GetProcesses();
Log($”Found {processes.Length} running processes”);
}
We use a System.Threading.Timer to periodically call the CheckProcesses method. There it enumerates the running processes and logs the count.
To install and run this service we need to configure a few more things. Open the Project Properties and go to the Debug tab. Set the “Start Action” to “Start project”.
Next, go to the Application tab and check the “Service application” option. This sets things up so the service can be installed and started outside of Visual Studio.
Finally, go to the Build tab and check “Register for COM Interop”. This registers some types needed by the service framework.
Now you can install and manage the service directly from Windows. Build the project, then right click the EXE in the Debug or Release folder and select “Install”.
Go to the Windows Services panel (services.msc) and you should see your service listed but stopped. Select it and click Start to run it in the background. You can view the logged messages in the Event Viewer.
To debug and develop further, you can start the service from Visual Studio. Any breakpoints hit or output displayed will happen in the IDE.
A few additional things to note about Windows services:
They run in a non-interactive session without a desktop. This means things like UI code won’t work.
Services run as the SYSTEM account by default for security. You may need to change the account if accessing network resources.
Services are meant to run continuously until instructed to stop. Errors should be handled gracefully to avoid crashes.
The OnStart and OnStop methods have strict time limits (usually 30 seconds) to complete any initialization/shutdown tasks.
Consider implementing some sort of heartbeating to monitor service health over long periods.
This covers the basics of creating a simple Windows service that runs some background logic using C# and .NET. Services provide a powerful way to run application logic reliably and independently of users being logged in. With some additional code, these principles can be applied to all sorts of useful system processes and daemons.