Skip to main content

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


Trending posts

AWS Lambda and containers

Did you know that you can package and deploy containerized AWS Lambda functions? This capability was introduced in 2019. Amazon AWS also provides base images in Python, Nodes, Java, .Net, and other supported runtimes. Photo by Tom Fisk from Pexels There are prerequisites and limitations which you can take a deeper dive in this article from AWS documentation. In general, consider Lambda for event-driven applications, meaning for solutions that are not continuously running.The AWS Lambda container approach supports: Consistency in the set of tools used for the Lambda-based applications Your image can be up to 10 GB You get the same benefits as the function packages, such as familiar container tooling, automatic scaling, high availability, and others There are existing base images for Lambda, available on ECR public and Docker hub that you can leverage In addition, AWS has made available a set of packages  that implement the Lambda Runtime API, allowing developers to seamlessly extend th

Essence of email deliverability - SPF, DKIM, DMARC and segmentation

Recently I attended a lively discussion on email deliverability hosted by Litmus, one of the leading providers of email marketing tools. As email marketers one of the core metrics we often rely on is email deliverability and the discussion was around how to improve the email deliverability in today’s world where our audiences are ever inundated with emails. In addition we often find ourselves operating in a very competitive landscape vying for these audiences' precious attention. Photo by Ivan Samkov from Pexels   Hence it’s becoming increasingly important to ensure our emails are reaching our audiences’ inbox and driving engagement. This is why email clicks and engagement are strong indicators of the performance of our email campaigns instead of just the delivery rate of our campaigns partly thanks to Apple’s Mail Privacy Protection . So let’s start with the distinction between email delivery and email deliverability . This is very well articulated by Dimiter Batmaziam in the Li

Your platform as a positive force in the world

If you are managing a platform, even if it is small, then you are leveraging one of the elements and popular channels used to build digital communities. These platforms, and channels, can come in the shape of websites, blogs, mobile apps, podcasts, vlogs, social media, or a combination of the ones mentioned. Photo by Tatiana Syrikova from Pexels   There are many reasons for building a community, such as sharing knowledge, promoting businesses, branding, the need for engaging with others, etc. However as Spiderman’s Uncle Ben said: “With great power comes great responsibility.” If you like to build better communities with more collaboration and less silos then how would you do it? How can communities come together to drive a “ positive force ”? The current world is mired in conflicts. How long are we willing to go on in such disarray? All the continents are in some kind of “a demonstration of partisanship, intolerance and selfishness”. There are nations in the Americas, Africa, Middl

Research around JIRA vs TFS

By: Carlos G.    An opportunity came from a colleague to discuss the case of company “X” for improving the ALM by introducing tools to this company. The challenge was to decide between Microsoft and Attlasian . He came to me because I’m a Microsoft kind of guy and he wanted the opinion from my perspective, not as a consultant, but as a friend of what he was trying to accomplish. He said that even though I was inclined to a technology I was able to explore other things and be “fair”. I agreed to be a part of his research because of 3 things: because of my curiosity I'm always willing to learn new techy stuff. Sometimes is good to be the dumbest one of the group. You learn so much! This was a story that I could blog about. (Of course no names are used in this post). My first impression was thinking “cool”; let’s compare Visual Studio TFS vs JIRA. Immediately I got a comment back with: “ Sure but JIRA by itself is more like an issue tracker in simple terms ”. That sa

This blog uses cookies to improve your browsing experience. Simple analytics might be in place for pageviews purposes. They are harmless and never personally identify you.

Agreed