Over the last seven years any time I needed to write a build script, I've turned to NAnt as the tool to get the job done. I’ve relied on NAnt so much that the NAnt task reference page is usually on my Most Visited page in Chrome. The concepts behind NAnt are straight forward and once you’ve understand the basics it’s a great skill to have.
My current project is using MSBuild as the principle build script and this week I had the pleasure of having to tweak it. Although I’m a little late to adopting MSBuild as a scripting tool, this was a good opportunity to get to know its idiosyncrasies and learn a new technology. My verdict? They share a lot of similar characteristics, but if you’re familiar with NAnt you’ll find that MSBuild has a few foreign concepts that take some time to wrap your head around.
While this is still new territory for me, I thought it would be fun to compare the two and share my findings here for my reference (and for yours!).
The Basics
Structure
At the surface, MSBuild and NAnt appear to related as they share a common lexicon and overall structure. The scripts are comprised of Projects and Targets.
NAnt: <?xml version="1.0"?>
<project default="MyTarget" >
<target name="MyTarget">
<echo message="Hello World" />
</target>
</project>MSBuild: <Project DefaultTargets="MyTarget"
xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Target Name="MyTarget">
<Message Text="Hello World" />
</Target>
</Project>
Execution of the scripts is nearly identical, with only minor differences in the input arguments:
nant -buildfile:example.build MyTarget
msbuild example.csproj /target:MyTarget
Tasks
Both NAnt and MSBuild share a rich Task functionality set and support the ability for writing your own Tasks if the default tasks aren’t enough. They also support writing custom tasks inline using your favourite .NET language.
Properties
The most notable difference between the two technologies starts to appear in how they handle Properties.
NAnt has a fixed schema such that all properties are defined exactly the same way. You reference your properties in your scripts by prefacing them with ${property-name}
Using properties with NAnt <property name="myproperty" value="hello world" />
<echo message='${myproperty}" />
MSBuild on the other hand leverages the self-describing nature of XML to describe properties. This can really throw you off, since your properties won’t adhere to a known schema which means there’s no IntelliSense support. This seems like an odd move as MSBuild is the underlying file structure for Visual Studio project files, but it provides an opportunity to provide additional meta-data about the properties, which I’ll explain later in this post.
Rather than use an element named “property”, any element that appears inside a PropertyGroup element is a property. Similarly to NAnt, you reference properties using a $(property-name) syntax except be sure to note this is round brackets instead of curly braces.
Using Properties with MSBuild: <PropertyGroup>
<MyProperty>Hello World</MyProperty>
</PropertyGroup>
<Message Text="$(MyProperty)" />
MSBuild also supports the concept of ItemGroups, which equate roughly to multi-valued properties. The closest equivalent in NAnt would be filesets, though they are only limited to certain tasks, like a list of files and folders to be used with the Copy task.
Much like Properties, the element name represents the name of the ItemGroup. You reference an ItemGroup using a @(ItemGroup-Name) syntax. By default, ItemGroup are evaluated as semi-colon delimited lists.
Using ItemGroups with MSBuild: <ItemGroup>
<MyList Include="one" />
<MyList Include="two" />
<MyList Include="three" />
</ItemGroup>
<Message Text="@(MyList)" />
Produces the output:
one;two;three
By default, when accessing items in an ItemGroup using the @(item-group-name) syntax, the items are concatenated using a semi-colon delimiter. You can specify different delimiters as well, for example the following produces a comma-delimited list.
<Message Text="@(MyList, ',')" />
Advanced Stuff
Conditions
There are times where you want to conditionally invoke a target, task or configure a property and both tools accommodate this. NAnt describes conditions in the form of two attributes: “if” or “unless” – unless is the opposite of if. NAnt also supports a very impressive list of built-in functions including string, file, date and environment routines. MSBuild doesn’t have extensive support for inline expressions but does offer a set of Property Functions and standard boolean logic. However, MSBuild has a very long list of Tasks and community extensions that provide coverage in this area.
To assist with the conditional expressions you may write, NAnt also ships with out of the box properties. MSBuild has considerably more reserved properties, though most of them seem centered around the Visual Studio compilation process.
Output
Sometimes your build script needs to control flow of execution based on the outcome of the preceding tasks. In the NAnt world, a lot of the default Tasks expose an attribute that contains the output.
This NAnt example directs the exit code of the Exec task to the property myOutput.
<target name="RunProgram">
<exec
program="batch.bat"
resultproperty="MyOutput"
/>
<echo message="${MyOutput}" />
</target>
MSBuild has a similar strategy, except there’s a finer level of control: all Tasks can contain an Output element that dictates where to direct output of the Task. This is advantageous if there are multiple output values that you want to collect from the Task.
This MSBuild example uses the Output element to put the value of the Exec Task’s ExitCode into the Property MyOutput:
<Target Name="RunProgram">
<Exec Command="batch.bat">
<Output
TaskParameter="ExitCode"
PropertyName="MyOutput" />
</Exec>
<Message Text="$(MyOutput)" />
</Target>
MetaData
Earlier I mentioned that MSBuild leverages the self-describing nature of XML to provide additional meta-data about properties (more specifically Item Groups). This loose format to describe our properties means that we can embed a lot of extra data that can be leveraged by custom Tasks. After this example, it’s clear to see how MSBuild and Visual Studio use meta-data to assist in the compilation of our projects.
We can embed meta data by adding custom children elements below each Item:
<ItemGroup>
<StarWarsMovie Include="episode3.xml">
<Number>III</Number>
<Name>Revenge of the Sith</Main>
<Awesome>no</Awesome>
</StarWarsMovie>
<StarWarsMovie Include="episode4.xml">
<Number>III</Number>
<Name>A New Hope</Name>
<Awesome>yes</Awesome>
</StarWarsMovie>
<StarWarsMovie Include="episode5.xml">
<Number>III</Number>
<Name>The Empire Strikes Back</Name>
<Awesome>yes</Awesome>
</StarWarsMovie>
</ItemGroup>
And we can access the meta data of each individual Item using the %(meta-name) syntax. For example, we can spit out only the awesome Star Wars Films by filtering them by their meta-data.
<Message Text="@(StarWarsMovie)"
Condition=" '%(Awesome)' == 'yes'"/>
The above displays the names of the episodes that are awesome (“episode4.xml;episode5.xml”) but there’s a really interesting and powerful aspect happening with the above statement. The “%” character accesses the individual items before they are appended to the output, which is very similar to a for loop. So where “@(StarWarsMovie)” sends the entire ItemGroup to the Message task, we can execute the Message Task in a loop using this syntax:
<Message Text="%(StarWarsMovie.Name)"
Condition=" '%(Awesome)' == 'yes'"/>
Which produces the output:
A New Hope
The Empire Strikes Back
There’s also a set of baked-in meta-data properties available to all ItemGroups. The most notable is the Identity meta-property which gives us the name of the individual Item.
Transforms
Another interesting feature that MSBuild provides is the ability to convert the contents of a list into another format using a transform syntax @( ItemGroup –> expected-format). When combined with Meta-Data, we’re able to create rich representations of our data. Sticking with my Star Wars theme (hey, at least I'm consistent), the following transform:
@(StarWarsMovies -> 'Star Wars Episode %(Number): %(Name)', ', ')
Creates a comma-delimited list:
Star Wars Episode III: Revenge of the Sith, Star Wars Epsiode IV: A New Hope, Star Wars Epside V: The Empire Strikes Back
Wrap up
While MSBuild shares a lot of common ground with NAnt, there are certainly a lot of interesting features that warrant a closer look.
Happy Coding.
