After I had written the chord image generating code itself I decided to make a little test app for it, both to teach people the correct format and just to play with. That little application can be found at http://chords.einaregilsson.com/. The chord images can have muted and open strings, finger positions, display the beginning fret for chords higher than the first five frets and display below the image which fingers are used for which string. They can also be generated in ten different sizes.

Lets look at some examples. The format of an url for a chord is:

http://chords.einaregilsson.com/[chordname].png?p=[fretpositions]&f=[fingers]&s=[size]

So, for a normally fingered E chord the url would be:

http://chords.einaregilsson.com/E.png?p=022100&f=-231–&s=2

The name is a simple string. The only thing to remember there is that if you want to use the # symbol you must encode it as %23, because otherwise the browser will not send the rest of the url to the server. If you have two chords with the same name you can differentiate them by naming for example one E5 and the other E5^II. This is done by writing the name as E5_II, with an underscore before the superscript. Below is an example of a C# chord in size 5

http://chords.einaregilsson.com/C%23.png?p=x4666x&f=-1333-&s=5

The fret positions run EAGDBE, use X for muted strings, 0 for open strings and other numbers for fret positions. If you are writing a chord that uses fret positions on and over the 10th fret you must write all the positions with a dash between them. A D bar chord on the 10th fret would then be written as

http://chords.einaregilsson.com/D.png?p=10-12-12-11-10-10&f=134211

The fingering positions also run EAGDBE. Use T for thumb, 1 for index finger, 2 for middle finger, 3 for ring finger and 4 for pinky. Use a dash, -, when no finger is on a particular string. Bar chords are inferred, if you write that you are using the same finger for different strings on the same fret, then a line will be drawn through them to indicate a barred chord. An example of that is the D chord above.

The size is just a number from 1-10. I like size 2 the best myself, and that is the default.

You can cut as much off the back of the url as you want. That is, you can skip the size, fingering positions and even fret positions, and they will use defaults instead. Default size is 2, default fingerings mean that no fingerings are written, and default fret positions are none. So, for example the following four urls are all legal (although the last one is not really a D chord since it contains no fret positions):

	http://chords.einaregilsson.com/D.png?p=xx0232&f=—132&s=2
	http://chords.einaregilsson.com/D.png?p=xx0232&f=—132
	http://chords.einaregilsson.com/D.png?p=xx0232
	http://chords.einaregilsson.com/D.png

You are free to link to images directly on http://chords.einaregilsson.com from your own website, although I make no guarantees about uptime, performance or anything like that. The images are cached for a week, so loading time should be fast after the first time.

The code for this was written in C# and is licensed under the GPL. The main class is called ChordBoxImage and it can save the generated image in a variety of formats to any output stream. The code for the image generator as well as the little test web site is available on GitHub. 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.

IIS Setup

Install the .NET 1.1 framework on your computer if it’s not already installed. Then start a command prompt as an administrator and then type %WINDIR%Microsoft.NETFrameworkv1.1.4322aspnet_regiis -i. This will setup asp.net 1.1 to work with IIS 7. Next you should open up the IIS manager. Select ‘Application pools’, and under ‘Actions’ on the right side of the screen select ‘Add application pool’. Give the new application pool a name, for instance ‘Asp.net 1.1′, set the framework version to ‘v1.1.4322′ and pipeline mode to ‘classic’. Save the application pool.

Compilation

Jomo Fisher figured out a very nice way to use the C# 1.1 compiler in Visual Studio 2005 by manipulating some MSBuild target files. Follow his instructions for all the projects in your solution. When that works, goto the project properties, goto the ‘Build’ tab and set ‘Output path’ to ‘bin’. Jomo’s method sets the output path to ‘bin.Net1.1Debug’ by default which won’t work for a web application, it needs the assemblies to be directly in the bin folder. Now you should be able to compile your web. If you try any .NET 2.0 specific stuff, like public class F<T>{} you should get a compilation error.

Debugging

If you want to debug your web using the .NET 1.1 framework you can’t use the Visual Studio built-in webserver. That webserver uses the .NET 2.0 framework and even though you’ve compiled your assemblies using the C# 1.1 compiler, there’s still the aspx pages themselves that need to be compiled and we want that to happen with the C# 1.1 compiler too. Otherwise you might run into a situation where you think your web is completely working in asp.net 1.1, then you deploy to an actual 1.1 server and it’ll crash if you accidentally used some 2.0 specific stuff in your aspx files. So what we do is this: Goto project properties and the ‘Web’ tab. Under the ‘Servers’ section change it so that you’ve selected ‘Use IIS Web server’. This will show you your project url which you can change. Then press the ‘Create virtual directory’ button. You MUST have started Visual Studio as administrator for this to work. Once you’ve done this you should go back to the IIS manager where you can now see your new virtual directory. Right click on it, press ‘Advanced Settings’ and there, under ‘Behavior’, you can select which application pool to use. Change it so that it uses your brand new 1.1 application pool.

Designer support

I’ve got good news and bad news. The good news is that you will be able to view your pages in the designer and lay out things and it will generate the aspx file correctly for you. The bad news is that it won’t generate the codebehind member variables for you. But theres not much to it, all it means is that when you’ve added a button and given it an id of ‘btnDoStuff’ then you should in your .aspx.cs file create a variable protected Button btnDoStuff;. It’s a little annoying but you get used to it. It shouldn’t be too hard to write your own macro to generate members from tags, maybe I’ll do it someday (or not). Whenever you add a new page you’ll get compilation errors because of the partial classes. What I usually do is delete the .designer.cs file and remove the ‘partial’ keyword from the main class. There’s also a using statement that references System.Web.UI.WebControls.WebParts that you’ll have to delete.

I tried one approach which was to have a pre-build event that changed the name of the class in the .designer.cs file and removed the ‘partial’ keyword. Then I made my normal class inherit from that class. That worked sometimes but sometimes members would just stop being generated so in the end I figured it wasn’t worth it and just started deleting the .designer.cs files instead. I still think creating your own macro to generate such a base class could be a good idea though.

Other issues

There are some other issues you might run into. Web.Config is one of them. You must remove stuff that wasn’t there in 1.1, like the <connectionStrings /> section. Other than that I don’t know of any major changes, but then again my Web.Config is really simple. And then you have to make sure yourself that you don’t try to use any of the stuff that wasn’t in 1.1. That means no masterpages, generics, partial classes or any of the new webcontrols that came with 2.0. Another thing you should be aware of is that you always need to run Visual Studio as administrator for the debugging to work.

And that’s it. This worked for me, I don’t know if it’ll work for you. There’s some hassle involved, but for me, having some of the cool VS2008 stuff available (hello javascript intellisense) more than makes up for it.