I can track the win percentage of the human team and the computer team, so far the computer team only wins about 35% of its games, but it’s a nice challenge to try to make it win more. And now that the game is live, and has lots of plays every day it’s a lot of fun to tweak the computer players, publish the new version and then see the next day if the win percentage goes up or down.

For my next project I think I’ll do something different. I’ve purchased the domain http://solitaire-cardgame.com and am going to try to create Klondike (classic solitaire) first, if that’s fun then I’ll probably add a few others later on.

UPDATE 28.06.2011: And now I have a new card game, Hearts…

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!

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

The problem

I’ve been annoyed by the eventhandler names generated by Visual Studio for years. No, I don’t really want to name my methods txtName_TextChanged, which does not match any reasonable naming convention and looks ugly. I usually prefer something like OnNameTextChanged or something similar. Another thing that has annoyed me is

this.Load +=new EventHandler(OnLoad);

instead of just

this.Load += OnLoad;

So, I figured I could probably hack something together to fix these problems fairly easily. As it turns out, some of it was easy, some of it was hard and some of it was impossible.

How do you use it?

In the Tools menu there is a new menu item, EventHandler Naming. That will give you the options window shown here. The “Pattern” is what is used to create the eventhandler names, you can use two macros there, $(EventName) and $(SiteName). EventName is pretty self explanatory, but the SiteName can be the name of the variable/component that owns the event being subscribed to, the typename of the type that owns the event (in the case of static events) or again the typename if you are subscribing to events within the class that owns the event. For both $(SiteName) and $(EventName) you can specify simple transforms like changing the case to camelCase, PascalCase, UPPERCASE or lowercase.

The “Omit $(SiteName) for own events” is for the case where you are subscribing to your own, or a base class event. At least for me, if I’m in a form and am subscribing to its Load event I don’t want the handler to be named OnForm1Load, I just want it to be named OnLoad. Whereas if I’m subscribing to an event from some variable then I want the variable name (sitename) to be a part of the event handler name.

The “Use delegate inference” does what is says. Instead of getting += new EventHandler(someName) you will get += someName.

Implementation: WinForms and WebForms

Luckily the Win and WebForms designers have a fairly nice API that you can hook into. I just created my own implementation of IEventBindingService and implemented the CreateUniqueMethodName method. For all other methods I just delegated to the real event binding service. The code to hook that up is as follows:

    internal class DesignerCreationListener
    {
        internal DesignerCreationListener(IDesignerEventService designerEvents) {
            designerEvents.DesignerCreated += (s, e) => e.Designer.LoadComplete += OnDesignerLoaded;
        }

        private void OnDesignerLoaded(object sender, EventArgs e)
        {
            IDesignerHost host = sender as IDesignerHost;
            if (host == null)
            {
                return;
            }
            host.LoadComplete -= OnDesignerLoaded;

            Type type = typeof(IEventBindingService);
            IEventBindingService originalService = (IEventBindingService) host.GetService(type);
            if (originalService == null)
            {
                return;
            }

            host.RemoveService(type);
            host.AddService(type, new DesignerEventBindingService(originalService, new PatternNameProvider()));
        }
    }

DesignerEventBindingService is my class, which takes the originalService in its constructor and delegates to it as necessary.

Implementation: Code Window

The code window implementation is basically a big hack. It’s the C# language service that takes care of inserting event handlers there and it basically has no hooks or extension points at all. (I would love it if someone proves me wrong on this). So, here I’m basically listening to two events, BeforeKeyPress and AfterKeyPress. I’m just checking whether the keypress is a tab key, doing some heuristics to make sure that we’re actually creating eventhandlers and not just pressing tab in some arbitrary place.

This is the reason why you get the old eventhandler name in the tooltip first after you press +=, the new name only comes after the delegate constructor is created. I tried everything I could think of to fix that, but the language service itself is responsible for showing that tooltip and drawing text on it and I can’t hook into that.

The language service is also the reason I have to show the delegate constructor while we are creating the name and only remove the explicit constructor afterwards for delegate inference. If I mess with the delegate constructor before the method is created then the language service just aborts the operation and the next tab key stroke won’t do anything.

So, overall it’s missing some things, but for the most part it does what you’d want.

Implementation: WPF / XAML

And this is the impossible part. The XAML designer doesn’t use the IDesignerHost interface at all, and as far as I could tell from looking at the VSX forum there is just no way to really extend the XAML editor in any meaningful way. It’s disappointing that they didn’t use the excellent IEventBindingService there, if someone knows a way that I could hook in here then please let me know.

Conclusion

I hope you find the extension useful, the source is GPL and available at https://github.com/einaregilsson/EventHandlerNaming . If you have any tips, suggestions, or bug requests send me an email or a tweet at @einaregilsson.  And please tweet and share this if you like it

if os.environ.get('SERVER_SOFTWARE','').startswith('Dev'):
    from google.appengine.tools.dev_appserver import FakeFile
    FakeFile.ALLOWED_MODES = frozenset(['a','r', 'w', 'rb', 'U', 'rU'])

I worked on it on and off for months. No pressure to finish since it was just a hobby project. And finally, on November 18th I launched the new version at http://www.idiot-cardgame.com and at http://apps.facebook.com/idiot-cardgame/ to play it within Facebook itself.

The new game has animated playing of cards, shows your avatars and tracks statistics. You can also choose cardbacks and cardfronts, animation speed and some other options, and there is a High scores page which shows the 10 best players.

Now, 6 weeks after launch it has about 250 registered Facebook users plus a lot of anonymous users. I wanted to allow anonymous play as well instead of forcing everyone to give their Facebook credentials. However, tracking of statistics and saving preferences requires Facebook registration. There are around 6-700 games played every day and the computer player wins around 45-50% of them.

All in all I’m happy with the game. I’ve been adding a few small features and fixing bugs since launch. The next major feature I’m planning is the ability to play against your friends. The newest App Engine SDK includes support for Comet style connections which would make this a lot easier than it was a few months ago.

Finally, some lessons learned:

• Create your basic game engine in vanilla javascript and use events (or callbacks) for rendering the actions. I did this and can run games for testing in a simple command line script, which is really nice while you’re developing the basic game.
• Make the human player and the computer player implement the same interface, and let the Game object be ignorant of which player is which. This gives you the ability to play two computer players against each other during testing, which helps a lot if you don’t want to actually play the game thousands of times during development. I even have hidden options to do this in production so I can just watch an animated game play out.
• Facebook SDK documentation is complete crap. Best resource to test things is http://fbrell.com.
• App Engine regularly throws errors when connecting to the Datastore. Not all the time, but it is something you have to plan for.

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.

There are a couple of other articles out there that approach the problem in a different way. Roy Osherove has an article where he shows how you can add icons without having satellite assemblies for them, but that has > 350 lines of code for loading the images yourself including P/Invokes and all sorts of stuff, and I didn’t really need such a heavyweight solution. To be fair, his solution does give you the ability to use .ico files as well, and offers transparency, but transparency can be achieved in an easier way.

I also found another article that shows how you can get transparency by using a special color that, as far as I know, is not documented anywhere officially. It also shows you how you can build a satellite assembly from Visual Studio without resorting to Notepad and the command line tools, but this approach uses a special project for the satellite assembly, which is completely unneccessary.

So, finally, my approach, which is really a refinement of the last article I mentioned. If your add-in is meant for only VS2008 then you can get away with having no satellite assembly, VS2008 falls back to looking in your main assembly for the resources if it doesn’t find a satellite assembly. If you want to support VS2005 you must have a satellite assembly for it to work.

So, assume we have a project named MyProject which will compile to an assembly called MyProject.dll. Here’s what you do:

1. Add a new ‘resources’ item to the project and give it the name “MyProject.en.resx”.
2. Go the properties for the item and set the “Custom Tool” field to nothing. This will remove the auto-generated code for the .resx file
3. Double click on the .resx file, this opens up the resource editor. There you can add an existing image (Add Resource->Add existing file). The image should be a 16×16 pixel bitmap image. It must be in True Color format. True Color is the same as a 24-bit bitmap.
4. If you want transparency in your image then use the special color: Red:0 , Green:254, Blue:0 . Note that it really is 254, NOT 255.
5. In the resource editor, give your image a name that is a number, e.g. 1. Note that you did not have to change the filename of your image file, just its name in the resource file.
6. Now add your command in your add-in file like so:

   commands.AddNamedCommand2(_addInInstance, "MyProject",
         "MyProject", "Executes the command for MyProject",
         false,
         1,
         ref contextGUIDS,
         (int)vsCommandStatus.vsCommandStatusSupported +
         (int)vsCommandStatus.vsCommandStatusEnabled,
         (int)vsCommandStyle.vsCommandStylePictAndText,
         vsCommandControlType.vsCommandControlTypeButton);
   

   There you must send in false and then the number you gave the icon in your .resx file, e.g. 1.

Now when you compile your solution, a satellite assembly with the name MyProject.resources.dll will automatically be created and put in a “en” subfolder of your output folder. If you only want to support VS2008 and don’t want satellite assemblies then you can name the .resx file just MyProject.resx instead, then no satellite assemblies will be created and the resources will be embedded in the main assembly.

And that’s it. Add more resources in Visual Studio, have things compile automatically and don’t touch command line tools, notepad, hundreds of lines of custom code or anything like that. I *think* it is enough to just have the “en” resources dll even if you use another locale, I’m pretty sure Visual Studio falls back to that if it doesn’t find a satellite assembly in your current culture. At least I have my Windows set up for Danish, but my “en” satellite assembly works just fine for me. Although, there doesn’t exist a Danish version of Visual Studio, maybe this works differently for localized Visual Studio, e.g. the German version. If someone has one of those and can test I’d love to know whether it falls back to “en” if nothing else is available. If it doesn’t then just create a few more MyProject.de.resx, MyProject.es.resx etc. to get more satellite assemblies. But like I said before, VS2008 and later doesn’t need this, so for that case just have the one MyProject.resx file.

I’ve made the small MyProject example and it can be downloaded here. Let me know if this works (or doesn’t) for you. Enjoy!