Part of a project I recently completed involved developing a custom email queue Windows Service in C# on the .NET 2.0 Framework. The application itself was quite simple. Unfortunately it had been some time since I wrote a Windows Service, and I hadn't written one on the 2.0 Framework and couldn't really remember much about it from the 1.1 days.
To the internet I went. I found lots of helpful articles on how to write the service, but not so many on how to start it after install, how to debug it, or how to add it to the uninstaller. However with a little imaginative searching and guesswork I managed to overcome. It sure would have helped me to have all of these topics in one place, so I figured I'd do a collection of articles for anyone out there struggling with the same issues.
This article is the first in a five-part series covering the following topics:
- Programming a Windows Service in C#
- Adding an Installer for Your Windows Service
- Getting Your Installer to Start Your Service
- Some Options for Debugging Your Windows Services
- Adding an Uninstaller for Your Windows Service
The examples in this series are written in C#, but this should help anyone out there wanting to do this on the .NET 2.0 Framework no matter if they're using C#, VB.Net, or any other language. This is particularly true with this subject since most of the work is actually done in the Visual Studio 2005 GUI and not in the code.
Let's get started!
Programming a Windows Service in C#The obvious first step is to program our Windows Service. Our project is going to write a message to the Application Log when the service starts, stops and at every 5 minute interval while running. We'll do this with the help of the Timer object, so you might also learn a thing or two about the Timer object in the process. Plus, we will write a slick little helper function for writing to the Application Event Log.
1. Select New Project... under the File menu.
This will add a new project to your Solution. But, if you didn't know that already we're in trouble!
2. Select a Windows Service Project.
Under Visual C# > Windows, select Windows Service. At this point you should also give your project a name. For my examples my project will be called
SuperService. Click Ok when you're done.
Since I'm not adding this project to a solution, a new solution of the same name will also be added for my project to reside in.
3. Delete Service1.cs and add your own.It's rather unlikely that you want your service to be called "Service1", so let's delete Service1.cs and add our own Service. After deleting Service1.cs, right-click on your project in the Solution Explorer and select
Add >
New Item... From the menu.
In the resulting window, select Windows Service and give your service a name (mine is Logger.cs), as seen in the image below. Click Ok and your new service will be added to your project.
Now that you have the Windows service you want, you need to indicate that it is to be run. Open Program.cs in code view and find the line similar to the one below:
ServicesToRun = new ServiceBase[] { new Service1() };
Replace Service1 with whatever your new service is called.
4. Add your Timer to the Windows Service.Drag and drop a Timer object from your Toolbox into the design view of your new service. It will probably be found under the Components category.
5. Set up your service and Timer's properties and events.Click the timer you just added (probably displayed as
timer1) and set its interval property to 300000 (that's 5 x 60 x 1000 for 5 minutes in milliseconds.)
Go into code view mode for your service.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.ServiceProcess;
using System.Text;
namespace SuperService
{
partial class Logger : ServiceBase
{
public Logger()
{
InitializeComponent();
}
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.
}
}
}
In there you'll see that two overrides for your service have already been added,
OnStart and
OnStop. Naturally,
OnStart runs when when you first start your service and the
OnStop runs when your service is stopped - Be it by a user, the system or by another program.
Each time your service is started all of the code in your
OnStart event must be executed. When starting a Windows Service, Windows only gives a fairly small amount of time for the service to begin before it times out. If your application can take a while to run, you will want the smallest possible footprint for your
OnStart event - Both to save the user from having to wait for the service to start and to ensure it doesn't time out.
One of the great things about using a Timer with a Windows Service is that its counter runs in a separate thread. So, in your
OnStart event only assign your EventHandlers and start your Timer. Perform the actual functionality of your service from the Timer's
tick event. This will allow for a quick startup of your service.
For our example, our project is just going to write an event to the Event Log when the service starts and stops and when the timer iterates. I wrote a basic helper function to simplify the actual writing to the Event Log. You can copy the code below and paste it into your class:
static void LogEvent(String Message, EventLogEntryType type)
{
String source = "Logger";
String log = "Application";
if (!EventLog.SourceExists(source))
{
EventLog.CreateEventSource(source, log);
}
EventLog eLog = new EventLog();
eLog.Source = source;
eLog.WriteEntry(Message, type);
}
Logging to the Event Log is a bit out of the scope of this article, but I do want to point out one line:
String source = "Logger";
This string specifies what you want displayed for the Source column in the Event Log.
Now, let's update our service's
OnStart and
OnStop events to write to the Event Log:
protected override void OnStart(string[] args)
{
LogEvent("This SuperService has started!", EventLogEntryType.Information);
}
protected override void OnStop()
{
LogEvent("This SuperService has stopped.", EventLogEntryType.Information);
}
Now we'll have entries added to the Event Log when the service starts and stops, but what about our timer?
namespace SuperService
{
partial class Logger : ServiceBase
{
public Logger()
{
InitializeComponent();
}
void timer1_Tick(object sender, EventArgs e)
{
LogEvent("This Timer has been ticked!", EventLogEntryType.Information);
}
protected override void OnStart(string[] args)
{
timer1.Tick += new EventHandler(timer1_Tick);
timer1.Start();
LogEvent("This SuperService has started!", EventLogEntryType.Information);
}
protected override void OnStop()
{
LogEvent("This SuperService has stopped.", EventLogEntryType.Information);
}
protected override void OnPause()
{
base.OnPause();
timer1.Stop();
}
protected override void OnContinue()
{
base.OnContinue();
timer1.Start();
}
static void LogEvent(String Message, EventLogEntryType type)
{
String source = "Logger";
String log = "Application";
if (!EventLog.SourceExists(source))
{
EventLog.CreateEventSource(source, log);
}
EventLog eLog = new EventLog();
eLog.Source = source;
eLog.WriteEntry(Message, type);
}
}
}
For this we add an event handler for the
tick event of our Timer to the
OnStart function of our Service. You might say to yourself, "But what if the service is started and stopped multiple times? Won't the event be excessively re-hooked?" In short, no. When you stop the service its thread closes, effectively killing off the hook. This is also why we don't need to stop the timer in the service's
OnStop function. It will be killed when the service stops.
Additionally, we added a
Timer1.Start() call to the
OnStart function, to get our Timer rolling. We also added
OnPause and
OnContinue overrides, with
Timer1.Stop() and
Timer1.Start() calls, respectively.
That sums up our introduction to programming a Windows Service. In
Part 2 we discuss
how to add an installer that will install our Windows Service. This gives us a chance to test out our code and simplifies the process of adding the service to other machines.
Continue to Part 2: Adding an Installer for Your Windows ServiceLabels: Coding
On this day in 1954 Edwin Howard Armstrong took his own life. Armstrong had many patents and was involved in one of the longest patent wars to date (involving the regenerative circuit). His greatest invention was frequency modulation radio, or FM radio. Armstrong patented it in 1933 as US patent 1941066 with the title of "Radio signalling system". FM produced a clearer static free sound compared to the already popular AM radio. Of course another fight ensued as big companies dig not want to lose the ground they made in AM radio. Then another patent war erupted, RCA claimed they invented FM radio and won in court. This insured that Armstong would not receive any royalties from FM radios sold. Armstrong was defeated and broke, he jumped to his death from the 13th floor of his apartment building on January 31, 1954. Armstrong's widow, Marion, renewed the battle with RCA and finally won patent rights. Nice to see that big business can be beat.
On this day in 1886 the 
