Windows Service Basics

The article details three different approaches to creating a .NET service. Most common is the timer-based service, which simply relies on a timer to invoke the background thread periodically. I also cover two other alternatives: using a single worker thread and using multiple worker threads. While the timer strategy is the simplest, the approaches using a single worker thread and multiple worker threads (specifically the multithreaded approach) offer some advantages. Writing a .NET service is very simple. You simply create a project using the Windows Service template. Then you initialize your service in the OnStart event and tear it up in the OnStop event. But the simplicity comes at a cost: The service doesn't provide any mechanism to invoke your worker function(s) periodically. So unless you want to execute some task just once when the service starts, the template code is not very useful. Listing 1 shows the OnStart and OnStop event stubs added by the template. Listing 1 OnStart and OnStop stubs created by the .NET service project template.
protected override void OnStart(string[] args) { // TODO: Add code here to start your service. } protected override void OnStop() { // TODO: Add code here to perform any tear-down necessary // to stop your service. }

The Timer Approach

Of course, it's not very difficult to make the service invoke your worker functions periodicallyit just takes a few extra lines of code to use a timer to activate the worker function periodically. The timer approach is the most common method and is probably the simplest to write and understand. You create a timer in the OnStart event and attach your worker function to the timer. Listing 2 demonstrates the timer approach.

Listing 2 OnStart method for the timer approach.

// declare class-level variable for the timer private Timer serviceTimer; ... protected override void OnStart(string[] args) { TimerCallback timerDelegate = new TimerCallback(DoWork); // create timer and attach our method delegate to it serviceTimer = new Timer(timerDelegate, null, 1000, _interval); }

DoWork is the method that contains code to do whatever you need to do periodically, when the timer fires. The code in Listing 3 simply writes to the event log. Listing 3 Worker method for the timer approach.
private void DoWork(object state) { if (_workStartTime != DateTime.MinValue) { // probably check how much time has elapsed since work // started previously and log any warning EventLog.WriteEntry("Warning! Worker busy since " + _workStartTime.ToLongTimeString(), System.Diagnostics.EventLogEntryType.Warning); } else { // set work start time _workStartTime = DateTime.Now; // Do some work // Note: Exception handling is very important here // if you don't, the error will vanish along with your worker thread try { EventLog.WriteEntry ("Timer Service Tick :" + DateTime.Now.ToString()); } catch (System.Exception ex) { // replace this with some robust logging technique

EventLog.WriteEntry("Error! " + ex.Message, System.Diagnostics.EventLogEntryType.Error); } // reset work start time _workStartTime = DateTime.MinValue; } }

At each timer event, we check whether work is going on from a previous event. This is done by setting the _workStartTime variable to DateTime.Now when work starts. The variable is reset to DateTime.MinValue when work is complete. If work is still going on at a subsequent event, we log a warning. Notice the error handling around the "work." If you don't have exception handling there and an exception occurs, you'll never know that an error happened, and your worker thread will simply die. But the service will keep running normally, unaware that the worker thread has terminated. A few lines of code accomplished what we wanted. But are there other ways to do what we did above? Definitely. Let's look at two other alternatives, which require slightly more code but are as elegant as the timer approach.

Alternative 1: Use a Separate Thread

The first time I wrote a service, I wondered whether we could do something like Listing 4, rather than go to the trouble of adding a timer. Listing 4 The unstoppable service.
protected override void OnStart(string[] args) { while (true) { // do some work // idle Thread.Sleep(0, interval, 0) } }

I soon realized that the service appears to be hung if I did this. When you start the service, Windows won't get feedback that the service has started, since the service blocks in the OnStart call. Windows will promptly report an appropriate error. Another catch is that you can't tell the service to stop, because it never leaves the OnStart event! But we can do something similar to achieve our objective of a periodic invocation of the worker method: We use a separate thread. Let's start by declaring some classlevel variables, as shown in Listing 5. Listing 5 Class-level variables for the single-thread approach.
// This is a flag to indicate the service status private bool serviceStarted = false; // the thread that will do the work Thread workerThread; ...

Listing 6 shows the matching OnStart. Listing 6 OnStart method for the single-thread approach.
protected override void OnStart(string[] args) { // Create worker thread; this will invoke the WorkerFunction // when we start it. // Since we use a separate worker thread, the main service // thread will return quickly, telling Windows that service has started ThreadStart st = new ThreadStart(WorkerFunction); workerThread = new Thread(st); // set flag to indicate worker thread is active serviceStarted = true; // start the thread workerThread.Start(); }

The code in Listing 6 instantiates a separate thread and attaches our worker function to it. Then it starts the thread and lets the OnStart event complete, so that Windows doesn't think the service is hung. Listing 7 shows the code for the worker function.

Listing 7 Worker method for the single-thread approach.

/// <summary> /// This function will do all the work /// Once it is done with its tasks, it will be suspended for some time; /// it will continue to repeat this until the service is stopped /// </summary> private void WorkerFunction() { // start an endless loop; loop will abort only when "serviceStarted" // flag = false while (serviceStarted) { // do something // exception handling omitted here for simplicity EventLog.WriteEntry("Service working", System.Diagnostics.EventLogEntryType.Information); // yield if (serviceStarted) { Thread.Sleep(new TimeSpan(0, interval, 0); } } // time to end the thread Thread.CurrentThread.Abort(); }

The function will go into an endless loop until the serviceStarted parameter is false. The parameter itself will be set to false in the OnStop event shown in Listing 8. Listing 8 OnStop method for the single-thread approach.
protected override void OnStop() { // flag to tell the worker process to stop serviceStarted = false; // give it a little time to finish any pending work workerThread.Join(new TimeSpan(0,2,0)); }

Note that we provide a reasonable amount of time to the worker thread (two minutes in Listing 8) to complete its work. But if it doesn't complete within that time, the workerThread.Join clause will terminate it.

Alternative 2: Use Multiple Threads

This technique is very similar to the single-thread alternative discussed previously, but extends it to use multiple threads. This pattern can easily replace the singlethread alternative, by using just one thread in the array. Let's jump into the code. First, we declare class-level variables, as shown in Listing 9. Listing 9 Class-level variables for the multithreaded approach.
// array of worker threads Thread[] workerThreads; // the objects that do the actual work Worker[] arrWorkers; // number of threads; typically specified in config file int numberOfThreads = 2;

Listing 10 shows the OnStart event. Listing 10 OnStart method for the multithreaded approach.
protected override void OnStart(string[] args) { arrWorkers = new Worker[numberOfThreads]; workerThreads = new Thread[numberOfThreads]; for (int i =0; i < numberOfThreads; i++) { // create an object arrWorkers[i] = new Worker(i+1, EventLog); // set properties on the object arrWorkers[i].ServiceStarted = true; // create a thread and attach to the object ThreadStart st = new ThreadStart(arrWorkers[i].ExecuteTask); workerThreads[i] = new Thread(st); } // start the threads for (int i = 0; i < numberOfThreads; i++)

{ workerThreads[i].Start(); } }

First we create an array of Worker objects of the required size. Worker is a separate class containing an ExecuteTask method that does all the work. Then we declare an array of threads and attach one Worker object to each thread, specifying ExecuteTask as the method to be called. Finally, we start all the threads. After that, the OnStart method completes and control returns to Windows. The ExecuteTask method is similar to the worker methods shown in the earlier examples (see Listing 11). Listing 11 Worker method for the multithreaded approach.
public void ExecuteTask() { DateTime lastRunTime = DateTime.UtcNow; while (serviceStarted) { // check the current time against the last run plus interval if ( ((TimeSpan) (DateTime.UtcNow.Subtract(lastRunTime))).TotalSeconds >= _interval) { // if time to do something, do so // exception handling omitted here for simplicity _serviceEventLog.WriteEntry( "Multithreaded Service working; id = " + this._id.ToString(), EventLogEntryType.Information); // set new run time lastRunTime = DateTime.UtcNow; } // yield if (serviceStarted) { Thread.Sleep(new TimeSpan(0,0,15)); } } Thread.CurrentThread.Abort();

Notice that we use a smaller interval for the Thread.Sleep method (15 seconds) to increase responsiveness when the service is stopped. If we didn't do this, the service would be blocked until the _interval period was complete (or would simply time out if the interval was too long). The OnStop event is very similar to the one we discussed for the single-thread method, except here it has to signal all the threads to stop, as shown in Listing 12. Listing 12 OnStop method for the multithreaded approach.
protected override void OnStop() { for (int i = 0; i < numberOfThreads; i++) { // set flag to stop worker thread arrWorkers[i].ServiceStarted = false; // give it a little time to finish any pending work workerThreads[i].Join(new TimeSpan(0,2,0)); } }

Comparing the Options

In addition to the implementation itself, the three methods differ in a few other aspects: Performance. There doesn't seem to be much of a difference, even though the timer approach requires a couple of extra threads for the timer. Implementation (coding). The timer approach is the simplest, singlethreaded is slightly more complex, and the multithreaded approach requires the most code. Ability to run multiple threads. This is inherently available in the multithreaded approach. The number of threads can be specified in the config file so that it's easy to increase or decrease the worker threads. You can also achieve multiple threads in the timer approach, but with additional code.

Setting different delay periods for each thread. Inherent in the multithreaded approach. You could specify the delay for each thread in the config file and make the threads sleep for each of their specified times. The timer approach doesn't have this flexibility; the timer fires at preset intervals, so you would have to go through some hoops to achieve this goal. Delay in one thread could hold up execution of other threads. This won't happen in the multithreaded approach. Each thread is executing unaware of the other threads. But in the timer approach, if we spawn multiple worker threads, the longest executing thread will determine when the next execution is possible. The following table compares the different approaches.
Feature Multiple threads Ability to set varying idle times for each thread Delay in one thread can hold up next execution for all threads Code complexity Timer resource required Timer-based Possible with additional coding No Yes Lowest Yes Single thread No N/A N/A Low No Multithreaded Yesnumber of threads can be varied without additional code Yes Nothreads execute independently of each other Medium No

It's also possible to spawn multiple services within the same service process. Listing 13 shows the Main() method that the .NET service template generates. Listing 13 Main method created by the .NET service template.
static void Main() { System.ServiceProcess.ServiceBase[] ServicesToRun; // More than one user service may run within the same process. To add // another service to this process, change the following line to // create a second service object. For example, // // ServicesToRun = new System.ServiceProcess.ServiceBase[] // {new Service1(), new MySecondUserService()}; // ServicesToRun = new System.ServiceProcess.ServiceBase[] { new Service1() }; System.ServiceProcess.ServiceBase.Run(ServicesToRun);

I haven't covered this option in this article because we're considering how to create background threads in a given service, rather than having multiple services running in the same process.

Conclusion
The article details three different approaches to creating a .NET service. While the timer approach is the simplest, the multithreaded approach is very flexible and can work for one to many threads. It also allows varying delay for each thread. Any execution delay in the worker method of one thread will not interfere with the execution of other threads.