Creating a Windows Service with C#, concluded

The Last Leg

We will be using a class from vbAccelerator.com, found here: http://www.vbaccelerator.com/home/NET/Code/Libraries/Shell_Projects/SysTray/
SysTray_Code_zip_SysTrayTester_SysTray_cs.asp, to interact with the system tray. The reason I use this class is that the .NET Framework does not expose any access to the system tray; we have to import Win32 API functions from various DLL files. The class from vbAccelerator.com handles all this and more-–it provides a balloon tooltip mechanism as an added bonus.

Event Logging

Using the Windows event log is a breeze with .NET. Using the System.Diagnostics namespace, which is already referenced in our TimeServerService class, we have access to the EventLog class. Before we actually code up any event logging, let’s at least make it configurable so that logging can be turned off without recompiling. We should also make the name of the custom log configurable.

Right click on the TimeService project, select “Add”,  “Add New Item”, “Application Configuration”. Leave the default name “App.config”. Open the App.config file and add a new node under configuration called “appSettings”. We will add two keys to the Application Settings section, “LoggingEnabled” and “LogName”. Your App.config file should look like this:

You can change the value of LogName to whatever you want. We will write our code so that any value other than “true” means that the logging functionality of the service is turned off. To use these settings, add a reference to the System.Configuration namespace to TimeServerService.cs:

Now we need to add a few properties and methods to our class. Since every time we need to add a message we have to check the LoggingEnabled setting, we will create a helper method in the TimeServerService class to handle writing the log entries. Add the following properties:

Initialize these fields in the constructor, like so:

The code above grabs our configuration settings and initializes the class's new fields accordingly. Next we need to create our helper method, or methods, to actually write the entries to the log. The EventLog.WriteEntry() method signature we will use accepts a string message and an EventLogEntryType type, and so will our helper method. We will create an overloaded version of our helper method that takes just an exception and one that takes just a string, defaulting to EventLogEntryType.Error and EventLogEntryType.Information, respectively. The methods are short and simple:

Now we can simply call Log(message) for general information messages and Log(exception) to log errors. The Log(message, type) version can be used for other types of messages such as warnings and audits if you decide to use those types later. Note that in the Log(message, type) method, we check to see if logging is enabled before writing anything to the event log.

Logging events

With the helper methods in place, actually logging events is a matter of calling Log(message). Typically you would put messages in OnStart() and OnStop() indicating service start and stop, and in this case you may want to log every time someone connects to the server. Add this line to OnStart():

And add this line to OnStop():

In the Start() method, inside the control loop, we need to check the number of bytes read to see if a request has been received and, if one has, to make a note of it. Add this line to the Start() method after the line reading “s.Send(time);”:

You have probably noticed that there are no try/catch blocks in this service. It would probably be wise to add one in our control loop! Wrap everything inside the while loop in a try statement, then in the catch, write to the event log, like this:

Now that logging is complete, let’s move on to creating our controller application. Be sure you reinstall the service first to activate the changes we have made.

Creating the Controller

Add a new Windows Application project to the TimeApp solution called “TimeServiceController”. You will see a form named “Form1” now. Change its Text property to “Time Service Controller”, and add the following label and buttons:

Rename them “StatusLabel”, “StartButton”, and “StopButton”. Double-click on the Start button, click back into Design View, and double-click the Stop button. This adds in the click event handlers for our buttons. Now select the “Components” section of the toolbox and double-click “ServiceController”. Change the ServiceName property of the ServiceController to “TimeServerService”. We are done with Design View now; time to switch to Code View.

Now that we have our buttons and service controller wired up, we just need to put a bit of code in the click handlers. Look how simple it is:

All we have to do now is set up a timer to poll the service status and update the status message in our controller. We will create the timer object in the constructor and call another method to check the status and update our label. The constructor should look like this:

The UpdateStatus() method should look like this:

Set this class as your startup project and run it for a test drive. See a problem? Even with the timer in place, it seems that our label does not stay quite in sync. To fix this problem, we need to use the Service Controller’s WaitForStatus() method, like this:

Using the SysTray Class

The last thing on our list is to send our TimeServiceController program to the system tray when it is minimized. We will also want to show a balloon with a message if the service status changes unexpectedly. Create a new class file called SysTray.cs in the TimeServiceController project and paste in the code from vbAccelerator.com: http://www.vbaccelerator.com/home/NET/Code/Libraries/Shell_Projects/
SysTray/SysTray_Code_zip_SysTrayTester_SysTray_cs.asp.

Add the vbAccelerator.Components.Shell namespace to your Form1 class file:

using vbAccelerator.Components.Shell;

Add a SysTray object as a class field:

private SysTray sysTray;

Initialize the SysTray object at the end of the constructor:

Now we need to wire up our form to keep track of when it has been minimized so we can hide it and add it to the task bar. Add this line to the end of InitializeComponent() method:

this.SizeChanged += new System.EventHandler(DoResize);

The Minimize() method looks like this:

If you run the project now you will see that when you minimize, it does indeed show up on your system tray and the main window vanishes from the taskbar altogether-–but clicking on the system tray icon does not restore it. That’s because we haven’t created an event handler for the sysTray.DoubleClick event. Add this line in the constructor:

this.sysTray.DoubleClick += new EventHandler(DoRestore);

And add this method:

Now when you run your controller application you can minimize it to the system tray and double click the system tray icon to restore it. The last thing we need to do is add a bit of code to our timed method UpdateStatus() to check for an unexpected service status and show a balloon tooltip. Since we will be stopping and starting the service with the buttons in our application, any service status change, when minimized, should warrant a popup balloon. Thanks to vbAccelerator.com’s SysTray class, this is pretty simple:

To test this tooltip out, run the application and minimize it. Then go to Computer Management -> Services and stop the TimeServerService. You will see a balloon popup notification within ten seconds!

The End

All done! We’ve done quite a bit in these past three articles and I hope you learned something you didn’t already know. We have created a basic TCP server and installed it as a Windows Service with configurable logging and a small application to stop and start the service that runs minimized on the system tray and notifies us of services status changes. You can use this service as a foundation for a lot of interesting stuff, and I encourage you to experiment with building a more advanced server and client and to add more complex features to the service controller.