In this post I’m going to go through the basics of using IKVM to cross-compile the Java libraries to .NET and allow the closure compiler to run on the .NET platform.

If you haven’t come across IKVM before, the short description is that it’s a platform bridge for Java to .NET. It translates Java byte code to MSIL, and provides a .NET compiled version of the OpenJDK runtime. You can find out more on the website – in short, it’s amazing.

There are two ways to roll with this. IKVM supports a both dynamic mode, where jars or classes are cross-compiled at runtime; and a static mode, where a compiler produces a DLL or EXE from the jars or classes. In the static case, the resulting DLL can then be used from other .NET code to integrate Java APIs into .NET applications.

Getting started

First thing’s first: download IKVM and the closure compiler jar. You will also need the json.jar library that can be found in the closure compiler source. (Note that none of the following requires a JRE or JDK for this to work – just the .NET runtime, version 2 and above.)

Extract IKVM and the closure compiler to separate folders on your disk, placing the json.jar file in the same folder as compiler.jar.

Running in dynamic mode

This is the simplest method of execution, as the ikvm executable works the same way that the JRE does. Open a command line in the folder where the closure compiler jar resides and execute:

[path-to-ikvm]\bin\ikvm -jar compiler.jar --js=[source-javascript] --js_output_file=[destination-javascript-file]

This will run the compiler and output the result to the specified location.

While this mode is simple, you will have noticed that it’s slow to run – it took about 15s on my system compared with less than 5s using the JRE. This penalty comes from the fact that IKVM needs to cross-compile the jar before it runs – let’s speed it up.

Static compilation

For this section, we’ll compile the compiler.jar to compiler.exe – a Windows executable that runs on the .NET runtime.

From the command line, execute the following:

[path to ikvm]\bin\ikvmc -out:compiler.exe json.jar compiler.jar

Note that we’re using ikvmc (the compiler) here, not ikvm (the runtime). The above command instructs the IKVM compiler to compile the two jars into a single executable, and put the result into compiler.exe.

Why json.jar? Good question. This jar is a static dependency of the closure compiler, though I’m not sure where it’s  used (by the closure compiler). Adding it to the command line in this way means that it is compiled into the same executable as as the closure compiler, making the resulting executable easier to handle.  It is possible to compile the json.jar separately, then reference the resulting DLL when compiling closure.jar:

[path to ikvm]\bin\ikvmc -out:json.dll json.jar
[path to ikvm]\bin\ikvmc -out:compiler.exe -reference:json.dll compiler.jar

Not rocket science – you’ll notice the json.dll is also output in the current folder, and that the compiler.exe decreases in size.

Now if you’ve executed the above commands, you will have noticed that a number of warnings are output by the compiler, for example:

Warning IKVMC0100: class "org.apache.xmlbeans.XmlCursor$TokenType" not found
Warning IKVMC0100: class "org.apache.xmlbeans.XmlCursor" not found
Warning IKVMC0111: emitted java.lang.NoClassDefFoundError in "com.google.javascript.jscomp.mozilla.rhino.xml.impl.xmlbeans.LogicalEquality.nodesEqual(Lorg.apache.xmlbeans.XmlCursor;Lorg.apache.xmlbeans.XmlCursor;)Z"    ("org.apache.xmlbeans.XmlCursor")

What you’re being warned about here is an unresolved dependency in the compiler.jar. The Rhino JavaScript interpreter, which is included by the closure compiler has a dependency on the Apache XML Beans project. This isn’t used by the closure compiler AFAIK, so it can be ignored. You could, however, get the XML beans project and start compiling that (and all its dependencies) but in this case it’s not worth it. The same goes for the ANT dependency that is also shown in the warnings. The closure compiler doesn’t use these bits so you can ignore it.

Running compiler.exe

Now you have the executable, but when it runs it will crash – why? Merely that the executable needs some IKVM DLLs present to find the core library parts. These are all present in the IKVM bin folder. The selection of these that we need is:

• IKVM.OpenJDK.Core.dll
• IKVM.OpenJDK.SwingAWT.dll
• IKVM.OpenJDK.Text.dll
• IKVM.OpenJDK.Util.dll
• IKVM.OpenJDK.XML.API.dll
• IKVM.Runtime.dll

The dependency list can be found by inspecting the executable for its library references, saving you from needing to copy the entire set of IKVM library DLLs.

Copy the above list from the IKVM bin folder to be alongside compiler.exe. You can now run “compiler -?” without issue.

Of course, compiling JavaScript is also on the cards:

compiler --js=[source-javascript] --js_output_file=[destination-javascript-file]

There’s no explicit use of  IKVM here – all that’s used are the runtime DLLs. If you look at the decompiled version of the code you’ll see that there’s very little extra weight added by IKVM, and some of that (the line number symbols) is optional.

Speed

Running a test on the JQuery source code on my machines resulted in the following results.

As you can see, while the runtime compilation option is expensive, the compiled .NET code runs at a comparable speed to its ‘native’ JRE counterpart. Jeroen Frijters has done an amazing job to get IKVM performing as it does.

This is just the start of what is possible – the real reason I wanted to look at the Closure Compiler is to see about integrating it with the Client Dependency Framework – a filter that enables minification and bundling via an ASP.NET handler. More on that to come…

This can be incredibly useful, surfacing compilation errors across the project rather than relying on picking it up at runtime.

However, I found that it slows compilation down quite significantly. It also seems to lock the VS interface, despite the fact that builds are meant to be in the background.

As a result, I turned it off, but I didn’t want to abandon it completely. I wanted to make sure that my AppHarbor builds would fail if a view couldn’t compile.

The solution is really simple; AppHarbor uses the Release build profile, so only switch compilation on for that profile. This is easily accomplished: add the <MvcBuildViews>true</MvcBuildViews> code to the PropertyGroup section in the project file that is conditional on the build configuration. For example:

<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <!-- other properties elided -->
    <MvcBuildViews>true</MvcBuildViews>
</PropertyGroup>

That said, I just had a problem that took me ages to sort out, though it is trivially simple in retrospect. I kept getting a ModelState error that ‘The value “x” is not a valid value for Id’. My controller method has a string id parameter, and that was being bound successfully. The error key didn’t have a path to indicate that it was further down the tree, just “Id”. Nuts.

There’s a behaviour of MVC that will bind route/query/form parameters to fields in object controller parameters. This can be incredibly intuitive, and very useful. You just can’t forget that MVC works this way.

So in my case, a model in the parameter list has an int Id property, and it was this property that was causing the problem. The solution? [Binding(Exclude="Id")].

// controller method definition
public ActionResult CategoryEdit(string id, [Bind(Exclude="Id")] ComplexModelObject model)
{
    return View();
}

// model object definition
public class ComplexModelObject
{
    public int Id { get; set; }
}

Thanks, stackoverflow.

Thankfully, this is easily accomplished by copying the default templates into your MVC project in a ‘CodeTemplates‘ folder.

The templates themselves are located deep in the bowels of your Visual Studio installation:
[VS install folder]\Common7\IDE\ItemTemplates\[CSharp | VisualBasic]\Web\[MVC 2 | MVC 3]\CodeTemplates

When copied into the root of your MVC project they will be picked up by the ‘Create View’ wizard et al and used instead of the default. Note that by default VS will try to run the T4 templates: don’t let it! If the dialog appears asking to run it, click Cancel (as many times as necessary), then clear the ‘Custom Tool’ property of each of the copied files.

See this excellent post on template overriding from the Visual Web Developer Team blog on MSDN for a thorough explanation and more details on T4 templates.

Via: Stack Overflow, David Hayden

Articles

• From nibble.be, an example project
• Emanuel Gaspar published a well-written article: “How to create a Custom Section in Umbraco 4″
• Morten Christensen (creator of the excellent Google Analytics plugin) had earlier contributed a similar article
• Richard Soeteman has some notes on compatibility issues for 4.0.x/4.5.x development

Notes

• For the icon of your custom section (specified in the umbracoApp table), it’s nicer to use a separate image file instead of updating core CSS files. Put the file in \umbraco\images\tray\ and use the file name as the appIcon column value (thanks Nibble). Doing this means you won’t tread on the toes of another package.
• Unless you need a different folder icon, go with the styles when inserting into umbracoAppTree.
• Don’t forget to add the name of your custom section to the language files.
• Take note of the compatibility issues with the new 4.5 tree. If you’re developing for prior 4.x versions, write it to be compatible from the beginning (see the above link).

One more thing

Lastly, an extra note (courtesy of my colleague, Jeroen B): if you want content to appear when you first see the section, or click on the root tree node, you need to configure the dashboard for your section. In the /config/Dashboard.config file, add a section element under the root dashBoard element:

<section>
  <areas>
    <area>customsectionname</area>
  </areas>

  <tab caption="CustomTabCaptionText">
    <control>/usercontrols/CustomTabControl.ascx</control>
  </tab>
</section>

The areas element defines the sections under which this dashboard tab will appear.

(Updated 2-Jun-2011 – see the bottom of the post for some notes on 64 bit machines)

This problem can manifest itself in a number of ways:

• You get an error that indicates that ASPX files are mapped to a static file handler
• You have multiple versions of the framework installed, your site gives a 404, and you get errors/warnings in the eventlog along the lines of “Unable to find schema for config section 'system.web.extensions/scripting/scriptResourceHandler'“, “Unknown attribute 'type'” where these errors come from the web.config of the web application you’re trying to access.

There are other possibilities for these errors, but a big possibility is that particular version of the .NET framework that your application is built to use is not registered in IIS. The most common reason for this is that you install IIS after the framework is installed. Obviously the installer can’t do the business when IIS isn’t around.

Note: you can have the correct framework selected in the IIS application pool settings, and your web.config can be perfect but you may still be experiencing this error.

IIS looked right to me, but it wasn’t finding squat. You may not see the ASP section for the website if no framework version is installed, but if say, .NET 4 is configured, and the 3.5 version that comes with 7 isn’t, your 3.5 sites will mysteriously fail. What fun!

The magic application that allows you to diagnose whether this problem is affecting you is aspnet_regiis.exe. This little tool is found in the framework install folder. Importantly, and counter-intuitively, to check the status of a particular framework version, you need to run the executable that is specific to that version of the framework. For example, to check 1.1, you need to open a command prompt and change to the %windir%\Microsoft.NET\Framework\v1.1.4322 folder.

To check that the framework is installed, run the command: aspnet_regiis -lv.

To install this version of the framework, use aspnet_regiis -ir. This installs the framework version, but doesn’t change the settings of existing IIS application pools.

See the reference topic: ASP.NET IIS Registration Tool (Aspnet_regiis.exe) on MSDN for more information.

Update: The aspnet_iisreg tool may be in your v4.x folder. And if you’re running on a 64 bit machine, you need the version in the Framework64 folder. (Thanks to an article on breaking changes in ASP.NET 4 by Scott Hanselman via IIS Manager can’t configure .NET Compilation on .NET 4 Applications on StackOverflow.)

var ordered = order.Lines.OrderBy(l => new { l.AdminCode, l.OrderLineNr});

I thought this was the way to do it; after, that’s the way that you use Join() for multiple properties. What it was however was a gap in my knowledge. The correct way to do it is:

var ordered = order.Lines.OrderBy(l => l.AdminCode).ThenBy(l => l.OrderLineNr);

This makes sense when you consider that the following are equivalent:

// methods, then LINQ syntax equivalent
var lines = order.Lines.OrderBy(l => l.AdminCode).ThenBy(l => l.OrderLineNr);
lines = from l in Lines orderby l.AdminCode, l.OrderLineNr select l;

// using a descending modifier
lines = order.Lines.OrderBy(l => l.AdminCode).ThenByDescending(l => l.OrderLineNr);
lines = from l in Lines orderby l.AdminCode, l.OrderLineNr descending select l;

Every time I use this kind of thing I consider what this would be if I needed to use an IComparer implementation, and become just that little bit happier.

Simply put:

public string SomeProperty { get; internal set; }

The internal modifier means that this property is only accessible to classes in the same assembly. Obviously asymmetric properties in general are applicable in other scenarios. Note too that while this is using the compact property syntax, the same principle holds for explicit setters.

The first part of the trick is to ignore the category. Firstly, because it’s removed in version 3.0 of the API, and secondly because it filters by name. This means that if you have 2 folders with the same name you’ll get dodgey results.

To do it right?

using Google.GData.Client;
using Google.GData.Extensions;
using Google.GData.Documents;

// snipped method declaration etc

var docService = new DocumentsService("company-app-version");
docService.setUserCredentials("username", "password");

var folderList = docService.Query(new FolderQuery());
var fLinks = folderList.Entries.Select(e =>
    new
    {
        // note how to get the document Id of the folder
        Id = DocumentsListQuery.DocumentId(e.Id.AbsoluteUri),
        Name = e.Title.Text
    });

foreach (var folder in fLinks)
{
    Console.WriteLine("Folder {0}", folder.Name);

    var fileList = docService.Query(
        new SpreadsheetQuery()
        {
            // setting the base address to the folder's URI restricts your results
            BaseAddress = DocumentsListQuery.folderBaseUri + folder.Id
        });

    foreach (var file in fileList.Entries)
    {
        Console.WriteLine(" - {0}", file.Title.Text);
    }
}

This will give you a list of the files in all your folders. Note you can get a list of all files in all folders a lot easier than this. That’s not the point: use this technique when you don’t want to get the whole list and filter after the fact.

Pertinent points:

• Line 15: getting the Id of the folder from its URI
• Line 27: setting the base URI of the query to be the folder prefix and the folder’s Id.

I wish I’d found this quicker…

(Updated to add clarification about example, and a couple of comments in the code)

To my surprise, all you need use is UriBuilder:

new UriBuilder(@"c:\path\to\file.txt").ToString();

This will output “file://c:/path/to/file.txt“. Simple, but far too much time wasted finding it…