- Windows Service Basics
- The Timer Approach
- Comparing the Options
- Conclusion
Like this article? We recommend
Like this article? We recommend
Like this article? We recommend
The Timer Approach
Of course, it's not very difficult to make the service invoke your worker functions periodically—it 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 class-level 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 single-thread 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));
}
}