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

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.

The original blog post about the architecture of the addin is now completely out of date as 90% of the addin is now written in IronPython with just a tiny shim layer of C# to instantiate the IronPython classes. I’ll probably write a blog post about that architecture seperately (or generally about how to write addins for VS in IronPython). Those interested in the architecture can download the source and look at it.

A nice tutorial with screenshots on how to setup the keyboard mappings and use the addin has just been posted at http://www.netsi.dk/wordpress/index.php/2009/12/02/zen-coding-a-very-fast-way-of-generating-html-elements-in-your-editor/ so go there for your setup instructions. And there is now a dedicated rss feed for updates at http://einaregilsson.com/zcupdates.aspx so subscribe to that to be notified of new versions. Eventually I’ll put an update check in the addin itself.

ZenCoding.VisualStudio v1.1.0.333

DOWNLOAD ADD-IN || DOWNLOAD SOURCE

RELEASE NOTES:

Version 1.1.0.333, 02.12.2009:

This release adds the following features

• Uses latest version of zencoding python library
• Wrap with abbreviation command
• Use, create, edit, delete custom snippets (Tools->Options->ZenCoding)
• Icons for commands
• Some bug fixes

Also a total rewrite with everything now written in IronPython

Version 1.0, 12.11.2009:

Initial release, features:

• Expand abbreviation

Original blog post follows:

Earlier this week, while reading Leon Bambrick’s blog I learned about a set of plugins, named “zen-coding”, which expand snippets of css-selector like code into full blown html and/or css elements. Leon’s article explains it better and there is also some documentation on the official zen-coding page. Anyway, this plugin is available for a number of text editors and IDE’s but not for Visual Studio. I use Visual Studio a lot and wanted zen-coding in there, so I decided to try and whip up a small add-in for it.

The original library is available both as JavaScript and Python. I really didn’t want to port or alter anything in the original code, since for future versions I want to be able to just drop in a couple of files from the original library and rebuild the add-in. The obvious choice then was to see if the library would work with IronPython. Fortunately the zen-coding library is just basic string manipulation and worked perfectly with IronPython right out of the box.

The next challenge was figuring out how to call into that from the add-in, which I wanted to write in C#. The library contained two functions I needed to be able to call. That turned out to be surprisingly easy. I made a wrapper class, ZenCodingEngine, which has two delegates with the correct method signatures, and then in its constructor I ran some custom python import code, and got references to the functions I needed and assigned them to my delegates. I changed that approach in the latest version and moved almost all of the logic into Python instead. Now the C# AddIn is very thin, it basically just receives events from VS and invokes a single exec_command() method that is defined in a python script. The interesting parts of that code are below:

private void ReloadPython()
{
  ScriptEngine engine = Python.CreateEngine();
  ScriptScope scope = engine.CreateScope();
  string folder = Path.GetDirectoryName(new
    Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath);
  List searchPaths = new List<string>(engine.GetSearchPaths());
  searchPaths.Add(folder);
  engine.SetSearchPaths(searchPaths);
  scope = engine.ExecuteFile(Path.Combine(folder, "vs_zen_coding.py"));
  engine.SetVariable(scope, "App", _applicationObject);
  execCommand = engine.GetVariable<Func<bool>>(scope, "exec_command");
}

public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled)
{
  handled = false;
  if (!CanExecuteCommand(commandName, executeOption))
  {
    return;
  }

  try
  {
    #if RELOAD_EVERY_TIME
    ReloadPython();
    #else
    if (execCommand == null)
    {
      //Load first time, to avoid making the VS startup slower
      ReloadPython();
    }
    #endif

    execCommand();
  }
  catch (Exception ex)
  {
    DisplayError(ex);
  }
  handled = true;
}

The ReloadPython() method is not called on startup, instead it is called the first time the command is called. IronPython performs well, but there is still some startup cost and I don’t want to add that to the startup time of Visual Studio. Instead you pay the price the first time you actually need it. Then we have the Exec method which is from a VS interface and is called when the command is invoked. There I use a compilation constant, RELOAD_EVERY_TIME, to check if I should reload my python script every time I invoke the command. This has proved to be INCREDIBLY useful, instead of constantly starting VS up again and again I just edit my python script, save it and the next time I execute the command the new code is used. And of course I turn this constant off for release builds.

Another nice trick to play around with the VS API, start up an IronPython shell and type:

This gets you a reference to the running instance of VS2009 which you can then experiment with.

You can download an installer for the add-in or get the source. The add-in is licensed under the GPL v3, the same license the zen-coding library uses. The add-in works for Visual Studio 2005, 2008 and 2010 beta 2.

Now, once you’ve installed the add-in, nothing happens. Well, actually what happens is there’s a new command available in Visual Studio, named ZenCoding.Expand, or ZenCoding.VisualStudio.ZenCodingAddIn.Expand, depending on where you are looking for it. (The keyboard mapping uses the full command id, but when adding it to a toolbar you get a shorter friendly name for it). By default it is not mapped to any keyboard combination. This is because it’s late and I can’t be bothered to figure it out I strongly believe that add-ins should not force a keyboard shortcut on you, possibly overriding something you have set yourself. So, map the command to your preferred keyboard shortcut (mine is Ctrl+E,Ctrl+K). Or you can drag the command onto a toolbar, which is fairly useless, but possible.

Enjoy!

UPDATE 13.11.2009: The main zen-coding developer also told me that I’m using an older version, the latest version has a lot more features, including user defined snippets. I’ll start looking at that when I have time, which won’t be just yet.

The only way to get a global keyboard working in .NET is by calling into the Win32 API. To register a global hotkey there is the aptly named function RegisterHotKey. That requires you to have a window handle however, and I wanted to make the application as simple as possible, so I used a lower level API call,
SetWindowsHookEx which lets you get notified of all keyboard activity on the system. I then check what keys are pressed and when the combination Ctrl+Shift+I is pressed the sound is played. There is only one way to exit the app, and that is by pressing the keyboard combination Ctrl+Shift+Alt+I, that cleans up the hook before exiting. So, the code is shown below, you can download the source or just download the program itself. Enjoy!

using System;
using System.IO;
using System.Media;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Forms;

class InstantRimshot {

    const int WH_KEYBOARD_LL = 13;
    const int WM_KEYDOWN = 0x100;

    delegate int Hook(int code, IntPtr wParam, IntPtr lParam);

    [DllImport("user32.dll")]
    static extern IntPtr SetWindowsHookEx(int code,
                                          Hook func,
                                          IntPtr hInstance,
                                          int threadID);

    [DllImport("user32.dll")]
    static extern int UnhookWindowsHookEx(IntPtr hookHandle);

    [DllImport("user32.dll")]
    static extern int CallNextHookEx(IntPtr hhook,
                                     int code,
                                     IntPtr wParam,
                                     IntPtr lParam);

    static bool IsPressed(Keys check) {
        return ((Control.ModifierKeys & check) == check);
    }

    static void Main() {

        Stream sound = Assembly.GetExecutingAssembly()
            .GetManifestResourceStream("InstantRimshot.rimshot.wav");
        SoundPlayer player = new SoundPlayer(sound);
        player.Load();
        IntPtr hookHandle = IntPtr.Zero;
        hookHandle = SetWindowsHookEx(WH_KEYBOARD_LL,
            delegate(int code, IntPtr wParam, IntPtr lParam) {
                if (code >= 0 && wParam == (IntPtr) WM_KEYDOWN) {
                    Keys vkCode = (Keys)Marshal.ReadInt32(lParam);
                    if (Keys.I == vkCode
                    && IsPressed(Keys.Control)
                    && IsPressed(Keys.Shift)) {
                        if (IsPressed(Keys.Alt)) {
                            UnhookWindowsHookEx(hookHandle);
                            Application.Exit();
                            return CallNextHookEx(hookHandle, code, wParam, lParam);
                        } else {
                            player.Play();
                        }
                    }
                }
                return CallNextHookEx(hookHandle, code, wParam, lParam);
            }, IntPtr.Zero, 0);
        Application.Run();
    }

}

Here’s how it works. If you enter a single line that ends with ; it is evaluated immediately. If it doesn’t start with if,while,var,try,do,with,function,switch,for or print it is assumed to be an expression and its value is printed to the screen. If a new line doesn’t end with ; is is assumed to be the beginning of a larger code block. In that case the script will keep reading in code without evaluating until either you end a line with ;; or you enter a line which consists of only one ;. The script also includes a convenience function called print() to print expressions. The script just uses a single variable, _$, so it won’t conflict with variables you define when using it. Writing a single line with just the word ‘exit’ will stop the script. Below you can see an example of the usage of the REPL. This sample is actually a online version that I did for fun, you can write in any command in it and try it out, it works exactly the same as the real script, although the online version took quite a bit more code. It even has command history, activated with the up and down arrow keys. (There are some issues in Internet Explorer, tab key doesn’t work and strings with html entities my display incorrectly, because of weird behaviour with <pre> tags and the .innerHTML property).

Download script | View script syntax highlighted

Enjoy!

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])