Follow me on twitter @einaregilsson to get notified of updates and other cool extensions and stuff.

At work I sometimes run into “evil twin” methods in our codebase. Those are methods that at a glance look almost exactly the same and where one has obviously been copy pasted from the other but then they have gotten out of sync over time. In these cases I try to refactor the two methods into one and add parameters for any behaviour that was different in the two original methods. But it can be hard to tell exactly what has changed between the two methods, especially when they are dozens of lines each. When dealing with this I used to copy each of the methods into their own temp file and then run a diff tool on them. After doing this a few times I got annoyed at the process, and decided to automate it somehow.

I’ve been playing around with Visual Studio extensions a lot lately and so I decided to make one for this problem. The extension is called ClipboardDiff and is now available in the Visual Studio Gallery. The idea is that you copy the first part of text you want to compare, then you select the next part you want to compare and then run the command ‘Diff selection against clipboard’. The command is available by right clicking on the selected text, it’s at the bottom of the context menu, or you can invoke it with they keyboard combination Alt+Shift+J. If you want to bind it to another keyboard combination just go into Tools->Customize->Keyboard and search for ‘ClipboardDiff’, it’ll find the command.

You can self choose which diff tool to use, to configure it go to Tools->ClipboardDiff settings and there you can enter the path to your diff tool of choice, and the arguments you want to pass to it. The placeholder values $FILE1$ and $FILE2$ will be replaced by the temp file names once you invoke the diff command. ClipboardDiff knows the default locations of a few diff programs, so if you have Perforce Merge, Tortoise Diff or WinMerge installed you won’t have to configure anything (Those are just the tools I happened to have installed on my machine). If you haven’t configured which tool to use the Settings window will be opened the first time you try to run a diff.

You can download the extension in the Visual Studio Gallery and the source, as always, is GPL’d and available on Github at https://github.com/einaregilsson/ClipboardDiff. Enjoy!

Follow me on twitter @einaregilsson to get notified of updates and other cool extensions and stuff.

At work I often work on a solution that has around 25 projects. When one of the projects fails to build, Visual Studio insists on trying to build the rest of the projects, even though at that point I don’t want it to, since I’m never going to run the program when some of the projects have failed. Often the other projects depend on the project that failed, and the error list gets filled with errors from those projects that just obscure the root cause of the problem. So, I figured I could probably do something about it.

I googled around for a solution and found a StopOnFirstFailure property in MSBuild that sounded promising, but I couldn’t find any good way to hook into the VS->MSBuild relationship. I’m sure there is some way to do this, so if anyone knows, please let me know. The next thing I found was a tip from Steve Dunn. It’s a nice little macro that listens for an event that is fired after each project is built, and calls the Cancel Build command if a project has failed to build. You just open the Macro IDE, open the EnvironmentEvents.vb file and paste the following code in at the bottom:

Private Sub BuildEvents_OnBuildProjConfigDone(
                   _ ByVal Project As String,
                   _ ByVal ProjectConfig As String,
                   _ ByVal Platform As String,
                   _ ByVal SolutionConfig As String,
                   _ ByVal Success As Boolean) Handles BuildEvents.OnBuildProjConfigDone
    If Success = False Then 'The build failed...cancel any further builds.
        DTE.ExecuteCommand("Build.Cancel")
    End If
End Sub

This does 95% of what I wanted to do. But still, I’m not a big fan of Visual Studio Macros, I prefer extensions where possible so I can easily see in one place what things I have installed instead of digging through the Macro projects. I also wanted to activate the error window after cancelling the build and be able to turn this on and off easily. So, I made an extension out of it. The main thing in it is still the macro code from Steve Dunn above, but in addition the extension:

• Activates the error list after cancelling the build.
• Prints a message to the Build output window, saying why the build was cancelled.
• Adds a menu item to the Build menu, “Stop Build on first error”, which you can use to turn the functionality on and off easily.
• Is context aware, the menu item and functionality are only available in multi-project solutions, since it would be pretty useless in a single project solution.

And that’s it. You can download the extension in the Visual Studio Gallery, get the GPL’d source code at https://github.com/einaregilsson/StopOnFirstBuildError and follow me on Twitter @einaregilsson to get notified of updates and other new extensions. Enjoy!

The problem here is that you need an environment variable with your app id, which you can set with the following code:

os.environ['APPLICATION_ID'] = 'myapp'

After you do that you’ll get this error:

To fix that one you need the following lines in your test setup:

datastore_file = '/dev/null'
from google.appengine.api import apiproxy_stub_map,datastore_file_stub
apiproxy_stub_map.apiproxy = apiproxy_stub_map.APIProxyStubMap()
stub = datastore_file_stub.DatastoreFileStub('myapp', datastore_file, '/')
apiproxy_stub_map.apiproxy.RegisterStub('datastore_v3', stub)

This temp datastore is persisted just while you run your tests. But you can also give the datastore_file variable a real filename and then it will save the datastore between tests, or you could create different datastore files for different scenarios.

Finally, to put it all together, here is the setUp method for my TestCase classes:

class SomeTestCase(unittest.TestCase):
	def setUp(self):
		app_id = 'myapp'
		os.environ['APPLICATION_ID'] = app_id
		datastore_file = '/dev/null'
		from google.appengine.api import apiproxy_stub_map,datastore_file_stub
		apiproxy_stub_map.apiproxy = apiproxy_stub_map.APIProxyStubMap()
		stub = datastore_file_stub.DatastoreFileStub(app_id, datastore_file, '/')
		apiproxy_stub_map.apiproxy.RegisterStub('datastore_v3', stub)

Now, why did I need this? Well, I was loading my other assemblies from an unusual place and I wanted to subscribe to the AppDomain.AssemblyResolve event before any types in my assembly were initialized. This feature is clearly not something you’re going to need every day, (actually I can’t think of a single other use case where I’d need it) but if you do, here’s how I solved it.

I used the excellent Mono.Cecil library to create a small program that injects a module initializer into an existing assembly. Cecil is a fantastic library that makes it incredibly easy to manipulate assemblies and can do pretty much anything that you could possibly want to do with IL code. Using it I wrote a small program that simply takes in an assembly filename and the name of a parameterless static void method that exists in the assembly, and injects a module initializer that does nothing but call that method. The original code I wrote, the interesting part without all the error checking and stuff, is shown below:

string assemblyName = "Test.dll";
string typeName = "Foo.Bar.ModuleInit";
string methodName = "Run";

AssemblyDefinition assembly = AssemblyFactory.GetAssembly (assemblyName);
TypeReference voidRef = assembly.MainModule.Import(typeof(void));
var attributes = MethodAttributes.Static
                | MethodAttributes.SpecialName
                | MethodAttributes.RTSpecialName;
var cctor = new MethodDefinition( ".cctor", attributes, voidRef);

TypeDefinition type = assembly.MainModule.Types[typeName];
MethodReference methodRef = type.Methods.GetMethod(methodName,new Type[]{});
cctor.Body.CilWorker.Append(cctor.Body.CilWorker.Create(OpCodes.Call, methodRef));
cctor.Body.CilWorker.Append(cctor.Body.CilWorker.Create(OpCodes.Ret));
assembly.MainModule.Inject(cctor, assembly.MainModule.Types["<Module>"]);
AssemblyFactory.SaveAssembly(assembly, assemblyName);

I then added all the neccessary error handling, unit testing etc. and the resulting program can be downloaded here. The program is just a single executable since I embedded the Cecil assemblies as resources and load them by handling the AppDomain.Current.AssemblyResolve event. You can run it from the command line and give it the filename of your assembly and optionally specify the method to call and a key file to strong name sign the assembly after the injection. If no method is explicitly specified then the program looks for a type named ModuleInitializer (may be in any namespace) and looks for a method named Run in that type and calls that method in the module initializer.

Run without specifying the method, looks for ModuleInitializer::Run in any namespace.

InjectModuleInitializer.exe Test.dll

Run and specify the method as Foo.Bar.SomeClass::SomeMethod

InjectModuleInitializer.exe /m:Foo.Bar.SomeClass::SomeMethod Test.dll

Run and specify a keyfile to use for strong name signing

InjectModuleInitializer.exe /k:mykeyfile.snk Test.dll

Realistically though, if you want to do this you probably want to do it right after building your assembly.  The best way to do that is to use the <Exec/> command in MSBuild in the AfterBuild target. To do that you can have the following in your .csproj file:

<Target Name="AfterBuild">
    <Exec Command='InjectModuleInitializer.exe "$(TargetPath)"' />
</Target>

Or, if you want to explicitly specify the method to run:

<Target Name="AfterBuild">
    <Exec Command='InjectModuleInitializer.exe /m:MyNameSpace.MyClassName::MyMethodName "$(TargetPath)"' />
</Target>

If you have set up your project to sign your assembly you will have the name of the strong name file in the $(AssemblyOriginatorKeyFile) variable. You can sign the assembly after the injection with:

<Target Name="AfterBuild">
    <Exec Command="InjectModuleInitializer.exe /k:"$(AssemblyOriginatorKeyFile)" /m:MyNameSpace.MyClassName::MyMethodName "$(TargetPath)" />
</Target>

And there you have it. You can download the console program or get the source on GitHub and build it yourself (You can download a zip file there if you don’t want to mess with Git). Enjoy.

I wrote a blog post a while ago about how to get pretty wordpress permalinks on IIS using IIS’s 404 page, so I figured I might be able to hack something similar together for this. Just a bit about how the IIS 404 page works: when IIS doesn’t find an item for a request it will execute the 404 page with the missing page’s url as a querystring. So, if we make a request for http://example.com/doesntexist and the 404 page is /notfound.aspx then the server executes http://example.com/notfound.aspx?404;http://example.com/doesntexist. The important thing here is that IIS executes this in response to the original request, it does not redirect to this page. That means that even as we’re executing the 404 page the user still sees http://example.com/doesntexist in his browser url bar. (Note that when you set the 404 page in IIS it allows you to specify either file or url, you must choose url. Shared hosting webhosts typically offer just url, at least mine only does. Also, the 404 page you can specify in web.config is a completely different thing, that is redirected to and so is useless for this.)

When you create a new MVC project in Visual Studio you get a file called Default.aspx in your root directory. (Note: this whole article is about how things are in the MVC beta, they might change in other versions). In the codebehind file, Default.aspx.cs there is a page load method that does some rewriting and then executes an Mvc http handler. I set this file to be my 404 page in IIS (you might use a different file if you want it somewhere else) and then changed its Page_Load method to be like this:

public void Page_Load(object sender, System.EventArgs e) {
    string querystring = Request.ServerVariables["QUERY_STRING"];
    if (querystring.StartsWith("404;")) {
        int startPos = querystring.IndexOf('/', "404;https://1".Length);
        HttpContext.Current.RewritePath(querystring.Substring(startPos));
    } else {
        HttpContext.Current.RewritePath(Request.ApplicationPath);
    }
    IHttpHandler httpHandler = new MvcHttpHandler();
    httpHandler.ProcessRequest(HttpContext.Current);
}

If we step through this a bit, first it checks if the querystring starts with 404; in that case the page is being executed as a 404 page, otherwise we do what this file previously did. Then we parse out the path from our querystring, rewrite it into our current http context and then execute the MvcHttpHandler on it. So, all requests with paths like /cars/Ford/1990 will end up here where we parse the relevant bit out of them and execute them with MVC.

Now we have this working, but at the expense of ruining the real 404 system. Any 404 request will be routed through there, no matter what it’s for, so how can we handle real 404′s? What I did was to add a new Action to my HomeController called PageNotFound which simply looks like this:

public ActionResult PageNotFound(string path) {
    ViewData["path"] = "/" + path;
    Response.StatusCode = 404;
    return View();
}

and then I added a catch-all rout map at the very bottom of my route map, like so:

routes.MapRoute(
    "PageNotFound",                                      // Route name</span>
    "{*path}",                                           // URL with parameters</span>
    new { controller = "Home", action = "PageNotFound"}  // Parameter defaults</span>
);

The {*path} means that this will match any possible path, having it at the bottom means that it will only ever execute if no other route matches => this is executed for pages that don’t exist. Then it passes the non-existent path to the controller, which sets the status code to 404 and adds the path to the ViewData, so the view can print a nice error message. One thing I had to change also was to remove the Default route from the route map, the one that had the url defined as {controller}/{action}/{id}. I removed it because it matched any url with three components and in the case when the components didn’t match any controller or action I got some ugly error message about missing controllers when what I really wanted was a 404 page. Instead I just explicitly state my routes now and usually don’t have the {controller} or {action} in the urls. With a bigger site this might be annoying and there are probably cleaner ways to handle it so any suggestions are welcome in the comments.

So that’s it. It’s all a big hack, but it does work without reducing performance by mapping everything to asp.net. I’m also not sure if the raw logs will show all those requests as 404′s or 200′s since my webhost doesn’t let me see raw lows for my subdomains, but I think they’ll be marked as 200. This has also only been tested when the site is in the root folder, I don’t know if it will work unchanged if the application is in a subfolder on the server.

Original blog post follows:

The last few weeks my hobby project has been creating a cardgame in Javascript. I’ve always wanted to create a cardgame and I decided to use simple Javascript so I could make it available online since no-one wants to bother to download small games. I figured there were thousands of blackjacks and solitaires out there so I decided to create my favorite cardgame, Idiot. After googling around I found that there was a Wikipedia page about it under the name Shithead which listed all sorts of different variations. My variation uses the rules that I’ve usually used in real life:

• The point is to lose all your cards by putting them on the pile, a card that is put on the pile must be equal or higher than the top card of the pile. If you have no card to put on the pile you must take the entire pile.
• There are always three cards in your hand, if you have less than three you must draw enough cards from the deck to get three again. After the deck is finished no more cards are drawn.
• There are three downwards facing cards and three upwards facing cards on the table. You cannot play them until your hand is finished. You cannot look at a downward facing card before playing it.
• Before you start you can exchange cards from your hand with the upwards facing cards on the table.
• You can put a two on top of everything, it is the restart card.
• You can put a five on top of everything, it is the reverse card, meaning that in the next turn the opponent must put a card equal or lower than five.
• You can put a ten on top of everything and it burns the pile, and you get to put out the first card in the new pile.
• You can put out more than one card at a time as long as they have the same rank.
• If there are four cards with the same rank at the top of the pile then the pile is removed.
• If you have no card that you can put on top of the pile then you may draw the top card of the deck and put on the pile, if it is a legal move then you do not have to take the pile.

The game can be played at the url http://einaregilsson.com/idiot/. As for the implementation, don’t expect any animation or fancy stuff. You simply choose the cards you want to put out and press the Play selected cards button. When the computer is playing the cards simply disappear from its hand and show up on the pile. However there is a small delay between each move by the computer so you can see when it puts out two or more cards and when it’s drawing cards. As for the rule about drawing a card off the top of the deck when you have to take the pile, that is done automatically. You simply press the Take the pile button and you will see a new card appear at the top of the pile (given that the deck is not empty). If the move is legal then the pile will stay, if it is not legal you will get the whole pile in your hand.

The game is implemented in two files, cards.js and idiot.js. Cards.js is a generic library that has a base class for a card container and concrete classes for a hand, deck and card, it could easily be re-used for any card game. Idiot.js is the game itself, it works allright, although there are a lot of edge cases that could be added to the computer player to make it smarter. The code is pretty heavily commented so it should be easy to follow should anyone want to extend the game or use the library for something. The game files are licensed under a Creative Commons Attribution license and so can be used for pretty much anything, they have been tested on the latest versions of all the major browsers. Please leave any error reports or suggestions as comments on this page.

00:20:24,345 --> 00:20:25,200
Hello there.
How are you?

So I created a little script, suboffset.py, which takes in the name of a subtitle file and the offset to add to the file in milliseconds, modifies the file contents and writes it back out to the same file. Alternately you can specify – as the filename and then the script will read the file from stdin and write the output to stdout so you can pipe it together to write to another file. The original script was about 10 lines, but just to make it a little more useful I made it a module so you could get access to the script from other scripts and added the stdin option and some comments. You can view the script below or download the actual script here.

#!/usr/bin/python
"""
   Script to offset the time in subtitle files in the .srt format. Script
   takes in the filename and the offset (in milliseconds) to add or
   subtract from the subtitles. It then writes the new subtitles to the
   same file. Alternately you can specify the filename as '-' and then
   the script will read input from stdin and write output to stdout.

"""

__version__   = '1.0'
__author__    = 'Einar Egilsson'
__date__      = 'March 20th 2008'
__url__       = 'http://einaregilsson.com/2008/03/20/subtitle-fixer/' 

import sys, re, datetime

MILLISECOND = 1
SECOND = 1000 * MILLISECOND
MINUTE = 60 * SECOND
HOUR = 60 * MINUTE

def offset_time(time, offset):
    """ Takes in list with [hour, minute, second, millisecond] and returns
        it with offset milliseconds added and normalized
    """
    ms = sum(map(int.__mul__,  time, [HOUR, MINUTE, SECOND, MILLISECOND]))
    ms += offset
    return [ms / HOUR, ms % HOUR / MINUTE, ms % MINUTE / SECOND, ms % SECOND]

def fix_subtitles(lines, offset, output):
    """ Takes in list (lines) with all the lines from the subtitle file, adds
        offset milliseconds to it and writes the file to output.
    """
    for line in lines:
        pattern = r'(\d\d):(\d\d):(\d\d),(\d\d\d) --> (\d\d):(\d\d):(\d\d),(\d\d\d)'
        match = re.match(pattern, line)
        if match:
            nrs = [int(nr) for nr in match.groups(0)]
            start = offset_time(nrs[:4], offset)
            end = offset_time(nrs[4:], offset)
            output.write('%02d:%02d:%02d,%03d' % tuple(start))
            output.write(' --> ')
            output.write('%02d:%02d:%02d,%03d\n' % tuple(end))
        else:
            output.write(line)

def print_header():
    print 'Subtitle Fixer v%s' % __version__
    print 'Author: %s' % __author__
    print __url__
    print ''

if __name__ == '__main__':
    if len(sys.argv) != 3:
        print_header()
        print 'Usage: suboffset.py <filename> <offset-in-milliseconds>'
        print 'Use - for filename to read from stdin and print to stdout'
        sys.exit(1)

    offset = int(sys.argv[2])
    file = None
    if sys.argv[1] == '-': #Read from stdin and print to stdout
        fix_subtitles(sys.stdin.readlines(), offset, sys.stdout)
    else: #read from file and write to same file
        file = open(sys.argv[1], 'r')
        lines = file.readlines()
        file.close()
        file = open(sys.argv[1], 'w')
        fix_subtitles(lines, offset, file)
        file.close()
        print 'Finished adding %s milliseconds to %s' % (offset, sys.argv[1])

I created an interface called INode, which looks like this:

public interface INode
{
    INode Left { get;}
    INode Right { get; }
    string Text { get;}
    object Value { get; }
}

In every binary tree structure I’ve ever made the nodes have pretty much looked like this, so this interface should be general enough that I could use it again. Then I created a class called BinaryTreeImage, which takes the root node of the tree as an argument in the constructor. It has four public methods (+ some overloads) that you can use to view the tree:

//The bitmap object for the image
public virtual Bitmap Bitmap

//Saves the image to file as a .jpg
public virtual void Save(string filename)
//Saves the image to file in the specified image format
public virtual void Save(string filename, ImageFormat format)

//Writes the file to an outputstream in jpg format, for instance a response
//stream in an asp.net application
public virtual void WriteToStream(Stream outputStream)
//Writes the file to an outputstream in the specified image format
public virtual void WriteToStream(Stream outputStream, ImageFormat format)

//Saves the file as a temporary jpg file, then launches it so it will open in
//your default jpg editor
public virtual void Show()

In my current project I just added a -img switch to the program, and if it was set I used the Show() method to launch the image as soon as the tree was parsed. That made it a lot easier to work with and get a better grasp of the trees I was using.

When you draw the binary tree you have to figure out how much space it’s gonna need to draw all the nodes. The naive way of calculating this is to first find the depth of the tree, then figure out how many nodes can possibly be in the bottom row, with 2^maxdepth-1, and make the image wide enough to fit all those nodes in. Then you can just draw the nodes at the exact places that they should be if the tree was full and then everything is great, right? Wrong! I tried that approach first and while it works, it has some problems. As soon as you have a tree that’s more than 5 or 6 levels deep you start getting a reeaally wide tree! If the tree is full than that can’t be helped, that’s just how wide the tree has to be. But if you have a pretty sparse tree (like I did) then you start getting some really crappy drawings. For instance, the root node of my syntax tree always had only one childnode. So when I had a few levels I had an image that was something like 3000 pixels wide, but was only using the right 1500 pixels of all that space.

So I thought about how I could fit my tree in as little space as possible and I finally found a solution that works pretty well. Recursion to the rescue! What I do now is use a depth first traversal and on the way back up I calculate the width of every subtree.

protected virtual ImageNode CreateImageNodeTree(INode node)
{
    if (node == null)
        return null;

    ImageNode left = CreateImageNodeTree(node.Left);
    ImageNode right = CreateImageNodeTree(node.Right);
    ImageNode newNode = new ImageNode();
    newNode.Node = node;
    newNode.Left = left;
    newNode.Right = right;

    newNode.RightTreeWidth = (right == null) ? 0 : right.TotalWidth;
    newNode.LeftTreeWidth = (left == null) ? 0 : left.TotalWidth;
    newNode.TotalWidth = newNode.RightTreeWidth + newNode.LeftTreeWidth + NodeWidth + DX;

    return newNode;
}

So after that I have the right, left and total width of every subtree. Then I can just start on the root node, draw that in the middle, then call my left child with my co-ordinates and that node will draw itself at parent.X – me.RightTreeWidth and the right node will draw itself at parent.X + me.LeftTreeWidth. And so it goes on recursively until all the nodes are drawn.

I’m maybe not so good at explaining it, but below you can see how it works. Just add a few nodes to the binary tree and you’ll see what happens. This is inside the blog template so as the image gets larger it might get clipped off by the sidebar or something, but you can also view the example at http://einaregilsson.com/binary-tree-image/. You can also view the BinaryTreeImage class here or download the example project which includes the class, and the webpage to view it with. The code is released under the you-must-let-me-know license. Basically, do what you want with it, but let me know if you use it, just so I’ll know if anyone else finds it useful .

Binary Tree Image Generator

Enter a number between 1 and 100

  Add Number

using System;
using System.ServiceProcess;

public partial class DemoService : ServiceBase
{
    static void Main(string[] args)
    {
        DemoService service = new DemoService();

        if (Environment.UserInteractive)
        {
            service.OnStart(args);
            Console.WriteLine("Press any key to stop program");
            Console.Read();
            service.OnStop();
        }
        else
        {
            ServiceBase.Run(service);
        }

    }
    public DemoService()
    {
        InitializeComponent();
    }

    protected override void OnStart(string[] args)
    {
        // TODO: Add code here to start your service.
    }

    protected override void OnStop()
    {
        // TODO: Add code here to perform any tear-down
        //necessary to stop your service.
    }
}

This will allow you to use your program as either a normal console program or a windows service, with no special builds, #DEBUG directives, command line parameters or anything like that. What it does is in the Main method it checks the ‘Environment.UserInteractive’ property. This will be true when it is run from Visual Studio, or when you just click on the .exe file, but false if it’s being run as a service. When it’s run from Visual Studio or as a standalone program it will keep running until you press a key, then it will call your OnStop method and then terminate.

Two things to watch out for:

1. You’ll have to right click on your project in Visual Studio, choose Properties and select the Output type as ‘Console application’ for this to work.
2. If your Main method is not in your service class, you’ll have to add public methods to your class that can start and stop it, for instance add a public void StartConsole(string[] args) that just calls your OnStart, since OnStart and OnStop are protected methods and as such not accessible from other classes.

UPDATE: 16.08.2007

Reader Anderson Imes (who has a rather nice debugging solution of his own) pointed out some things to fix. One thing is that a Windows Service can run many services in the same process, the ServiceBase.Run method can take an array of ServiceBase objects. I still think that the code above is the best way to do it if you have just a single service, just keep the Main method in the service class. But if you’ve got multiple service objects then that doesn’t make sense anymore, we want to put our Main method somewhere else. And then we have the problem of not being able to call OnStart in the service objects, since it’s a protected method. We could define a public StartConsole method in all of them that calls the OnStart method like I described above, but that will get tiresome if you have many objects. Well, there is another way to do it with Reflection which I´ve written here below. The new code is basically the same as the first version, except that it has an array of ServiceBase objects, called servicesToRun, and loops through it, calling each object’s OnStart method through some neat Reflection tricks. When the user presses a button it will stop all services by calling their Stop method, which in turn calls the OnStop method that all Services must define.

using System.ServiceProcess;
using System;
using System.Reflection;

static class Program
{
    static void Main(string[] args)
    {
        ServiceBase[] servicesToRun = new ServiceBase[] { new Service1()
                                                        , new Service2()
                                                        , new Service3()};

        if (Environment.UserInteractive)
        {
            Type type = typeof(ServiceBase);
            BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;
            MethodInfo method = type.GetMethod("OnStart", flags);

            foreach (ServiceBase service in servicesToRun)
            {
                method.Invoke(service, new object[] { args });
            }

            Console.WriteLine("Press any key to exit");
            Console.Read();

            foreach (ServiceBase service in servicesToRun)
            {
                service.Stop();
            }

        }
        else
        {
            ServiceBase.Run(servicesToRun);
        }
    }
}

While using this trick has worked perfectly well for my services, which have all been pretty simple, it might not work for everyone. I’m sure there are a few things different between Windows Services and console programs that I don’t know about, and might make the console version of the program behave strangely in some cases. Imes also pointed out that there was no way to test pause-and-resume in the console version. The best way I could think of to mimic service events like these would be to read in keypresses in the main thread and do the appropriate action depending on the key pressed. For instance, instead of the “Press any key to exit” message, we might have “Press p to pause, r to resume, s to stop” and then the result of Console.Read() could be used to determine which action to take and which methods to call on the Service objects. However, I don’t have the time and interest to do it right now, so implementing it is left as an exercise for the reader .