Skip to main content

Custom Windows OS Service Experience

[PLACEHOLDER]



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

AGILE For DIGITAL AGENCIES

Introduction Some Digital agencies have a project process where waterfalls still plays a big part of it, and as far as I can tell, the tech team is usually the one suffering as they are at the last part of the chain left with limited budget and time for execution. I do believe that adopting an Agile approach could make a Digital Agency better and faster. In this article I’m presenting you just another point of view of why it make sense looking at Agile Methodology.  Why Agile for a Digital Agency? The Agile movement started in the software development industry, but it has being proven to be useful in others as well. It becomes handy for the type of business that has changing priorities, changing requirements and flexible deliverables. In the Digital Agency of today you need a different mindset. Creative will always play a huge role (“the bread and butter”). But the “big guys” need to understand that without technology there is no Digital Agency. Technical resources are

AI with great power comes responsibility

Generative AI continues to be front and centre of all topics. Companies continue to make an effort for making sense of the technology, investing in their teams, as well as vendors/providers in order to “crack” those use cases that will give them the advantage in this competitive market, and while we are still in this phase of the “AI revolution” where things are still getting sorted.   Photo by Google DeepMind on Unsplash I bet that Uncle Ben’s advise could go beyond Peter Parker, as many of us can make use of that wisdom due to the many things that are currently happening. AI would not be the exception when using this iconic phrase from one of the best comics out there. Uncle Ben and Peter Parker - Spiderman A short list of products out there in the space of generated AI: Text to image Dall.E-2 Fotor Midjourney NightCafe Adobe Firefly

Designing Habit Forming Mobile Application

Mobile Applications have become an integral part of our daily lives - we use mobile apps as alarm clocks to wake us up in the morning, to create to do lists when we start our day, to communicate with our colleagues at work via apps like Skype. We even check reviews of restaurants to visit on apps like Yelp and we seek entertainment on apps like Netflix and spotify. So what drives us to use these apps so seamlessly in our daily lives? Why we prefer some apps over others? Is there a science behind designing successful mobile apps like Facebook?  Photo by Peter C from Pexels A study in US revealed that a user between the age of 18 and 44 visits the Facebook app on average 14 times a day [1]. This shows that using the Facebook app is a daily routine for many of its users. This makes Facebook a great example of a habit forming mobile app which is designed with human psychology in mind that encourages habit forming behavior in its users .   I recently attended a seminar on the de

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