introduction

at the beginning, there was no easy way to build a windows service using visual studio and .net framework. now that microsoft has integrated this functionality as a template and a class library, it's much more easy to do that. this is good, but to test your newly created service you have to deploy it. that means you must add an installer and build a whole msi file and run it in your environment. once deployed, you can start it with windows service controller and attach a debugger to it.

i don't know how this sounds to you, but to me it is too much unneeded work to do a quick test. this article describes a much more easy way to do that.

using the code

you will find a sample application using this concept. here is how it works.

first you need a working windows service. (for more information, refer to this.)

in visual studio, building a web service is easy. create a new project and select windows service template.

then add servicedebuggerhelper project to your solution and a reference to it. you can find it in the sample code.

by default, when you create a windows service project, visual studio will create two classes: a program class and a service1 class. here is what the program class looks like:

static class program 
{ 
    /// <summary>
    /// the main entry point for the application. 
    /// </summary>
    static void main() 
    { 
        servicebase[] servicestorun = new servicebase[] { new service1() }; 
        servicebase.run(servicestorun); 
    } 
}

the first thing we have to do is to surround that code with a conditional statement to let us control if we want to run as a real service or just in debugging mode.

 static class program 
{ 
    /// <summary>
    /// the main entry point for the application. 
    /// </summary>
    static void main() 
    { 
        if (args.length > 0 && args[0].tolower().equals("/debug")) 
        { 
            application.run(new servicerunner(new service1())); 
        } 
        else 
        {        
            servicebase[] servicestorun = new servicebase[] { new service1() }; 
            servicebase.run(servicestorun); 
        }
    } 
}

in this new program class, servicerunner will be acting as a service host. to make it work, you have to add the "/debug" command line option in your project properties.

go to project -> ... properties -> debug and type /debug in the command line arguments field.

from there, you have two options to make your service debuggable. either you implement idebuggableservice or inherit from debuggableservice base class.

implementing idebuggableservice interface

if you already subclass servicebase and use that subclass for all your services or if you just want to have full control over the implementation, you should implement the idebuggableservice interface. here is its definition:

public interface idebuggableservice
{
    void start(string[] args);
    void stopservice();
    void pause();
    void continue();
}

notice that the stop method is called stopservice to avoid conflict with the existing stop method of the servicebase class.

here is a sample implementation of this interface:

public partial class service1 : servicebase, idebuggableservice        
{
    //
    // your existing service code
    //
    // ...
    //
    
    #region idebuggableservice members

    public void start(string[] args)
    {
        onstart(args);
    }

    public void stopservice()
    {
        onstop();
    }

    public void pause()
    {
        onpause();
    }

    public void continue()
    {
        oncontinue();
    }

    #endregion
}

subclassing debuggableservice

subclassing your service from debuggableservice is even more simple. all you have to do is change the base class from servicebase to debuggableservice.

public partial class service1 : debuggableservice        
{
    //
    // your existing service code
    //
    // ...
    //
}

all the control methods are already implemented by debuggableservice.

points of interest

in my sample code, i added a windows form class to let you start, stop and pause your service. you can use it as is, build your own controller interface or just call the methods in your program class. it is up to you.

of course you should still deploy your service to give it the final test run. one good reason to do this is to test the actual security context in which your service will run. it will not have the same permission as when you run it in visual studio, but this technique can speed up the development process.