Custom Windows OS Service Experience




Introduction:

In this article we present some lessons learned and tips experienced through a Windows service development. This article is not going to show you how to create the Windows service project, rather it will talk about converting a console app into a Windows service for debugging purposes. It will also present some tips and references links that were checked by the team while they were going through the development.

For this and any project some basic items:
  • coding: always try to have in your solution a Unit testing project, at least to cover some of the main components. In normal development shops this is probably the norm, but in ad agencies, sometimes because budget and project size they skip this important step. With it you can verify the main functions and what may take time at the beginning to setup, it actually payed-off throughout the development and implementation of the service. 

  • coding-structure: Code that is well organize, different layers and libraries with specific functionality, definition of contracts that make sense. 

  • coding - best practices and used of patterns: Following the item,  mentioned above, you would have an easier code to maintain if you implement the right rules and bend the ones that can. As an example for the Windows service that I was creating I had the need of writing to the eventlog (system.diagnostic) and also using the log4net library for writing additional logs. At the starting point there was repeating code in different functions.


A refactor was in place for reducing the duplicated code. Using the .net delegate and event made possible to do some decoupling as well. Just to mention an scenario in our solution, when a notification got triggered it called the event for tracking the action into the logs (let’s say for debugging and troubleshooting purposes in case something went wrong). If we think about it this could be an example about implementing the Observer pattern(* You can read more by following one of the links in the references section at the end of the article).

Here is
a first version of a piece of the code, showing an example of using delegates and events (Since then the code has changed but at least it shows the idea):

namespace ClassNotification {
public delegate void NotificationEventHandler(object sender, NotiEventArgs e);
public class NotificationCaller
{
#region "variables"

private log4net.ILog Logger;
private System.Diagnostics.EventLog eventLog1;
#endregion
#region "Event section"
public event NotificationEventHandler Noti;

protected virtual void OnNoti(NotiEventArgs e)
{
    if (Noti != null)
     Noti(this, e);
}
#endregion

#region "notification delivery - mail"
public NotificationCaller(log4net.ILog logger, System.Diagnostics.EventLog eventlog)
{
   this.Logger = logger;
   this.eventLog1 = eventlog;

}
private bool SendNotification(string message)
{
   string TheSender = Configu.FromAddress;
   string TheRecipient = Configu.ToAddress;
   bool answer = ClassNotification.Notification.EmailSend(SOMETHING SOMETHING", message, TheSender, TheRecipient);

   NotiEventArgs notieventArgs = new NotiEventArgs(answer, Logger, eventLog1);
   OnNoti(notieventArgs);

   return answer;
}

  public bool SendNotificationExecution(string response, string StatusOfExecution)
  {
   EventListener listener = new EventListener(this);

   bool answer = false;
   answer = SendNotification("SOMETHING " + StatusOfExecution + ". Date: " + DateTime.Now.ToLongDateString());
   return answer;
  }

#endregion
}




/// the event listener class
///

class EventListener
{
private NotificationCaller notificationCaller;

public EventListener(NotificationCaller notiCaller)
{
   notificationCaller = notiCaller;
   notificationCaller.Noti += new NotificationEventHandler(NotiCalled);
}

private void NotiCalled(object sender, NotiEventArgs e)
{
   if (e.Answer)
   {
     e.Logger.Info("Info: Notification delivered!");
     e.eventLog1.WriteEntry("PROJECT- Notification delivered!" + DateTime.Now.ToShortDateString(), EventLogEntryType.Information);
   }
else
{
   e.Logger.Info("Error with transaction: Notification delivery failed. Check mail server");
   e.eventLog1.WriteEntry("PROJECT- Notification delivery failed. Check mail server" + DateTime.Now.ToShortDateString(), EventLogEntryType.Error);

  }

 }

}



/// the custom eventArgs class for the notification event
///

public class NotiEventArgs : EventArgs
{
   public bool Answer;
   public log4net.ILog Logger;
   public System.Diagnostics.EventLog eventLog1;
   public NotiEventArgs(bool answer, log4net.ILog logger, System.Diagnostics.EventLog eventlog1)
{
   this.Answer = answer;
   this.Logger = logger;
   this.eventLog1 = eventlog1;
  }
 }
}

For a quick implementation you could do something like this:
Notification.NotificationCaller oNoticaller = new Notification.NotificationCaller(logger, eventLog1); bool answer=false; answer = oNoticaller.SendNotificationExecution(response, StatusOfExecution);

  • Debugging the Windows service: You can start by building a console app, for simplicity and quick debugging. After the basic functionality is done the next step is to convert it into a Windows service. If you search for it on the web you will noticed that others have gone through the same.  

    By using this approach you can switch and run as a console app or as a windows service whenever you need to:
    static void Main(string[] args)
    {

        ServiceBase[] programService;
           programService = new ServiceBase[]
           {
              new Program1()
           };
              if (Environment.UserInteractive)
              {
                 //for debugging purposes
                 RunInteractive(programService);
              }
              else
                  {
                     ServiceBase.Run(programService);
                  }
              }
    Obviously for a service you have add the required methods like OnStart(), OnStop(). Note: More about this in my reference links. 

  • Debugging a Windows service: The previous item gives a useful option (having it as a console app).


Another option would be installing the service and then, using Visual Studio, attaching the process from the debug menu and debug away!

  • Installing a Windows service: installUtil would be a manual installation. Which usually you’ll find it in [DRIVE]:\Windows\Microsoft.NET\Framework64\v4.0.30319. An example would be:

installutill [drive]:\[location]\service.exe

keep in mind that you need to add an installer to your project. If you want the details I would advice to go to this link http://msdn.microsoft.com/en-us/library/zt39148a%28v=vs.110%29.aspx and follow the setps in the adding Installers to the Service.
another installation approach, aside using the installUtil, is by using InstallShield Limited Edition Project; which would be an automatic way of installing it. This is as close as an MSI it can get… I believe, at least until the date of this article. I haven’t done it, so I cannot guarantee the success on this one. But I left you a link under the reference section for you to explore. 
Final Words:
This solution was right for us at the moment. Based on requirements check your options and evaluate if a Windows service, API, SSIS, or whatever that you have in mind is the correct decision for the case considering the technology, maintenance, scalability and budget.

But whatever you do always follow best practices and value the lessons learned, as that experience can be applied for future projects, helping you improve on your delivery.

Reference:

TDD (Test-driven development):


Observer pattern - delegates & events:

.Net application console as a Windows Service:

about thread-safe tips:


Debug a Windows service app:

How to create a setup project for Window service


Install and uninstall services using InstallUtil:

Add installers to your service:
http://msdn.microsoft.com/en-us/library/ddhy0byf(v=vs.110).aspx


Previous
Next Post »