Nested elements in custom NAnt tasks

There’s a great post here detailing how to add nested elements within a custom NAnt task. I was writing a task to create IIS websites, and wanted to be able to specify multiple bindings, for example:

<IIS.Website.Create name="MySite" physicalPath="path">
    <bindings>
        <binding type="http" ip="1.2.3.4" port="8080" host="domain.com" />
        <binding type="net.msmq" host="localhost" />
    </bindings>
</IIS.Website.Create>

The important NAnt attributes you’ll need to know about are:

  • BuildElement – denotes a property as representing a nested element within a task, e.g. the <bindings> element above
  • BuildElementArray – denotes a property as representing an array of nested elements, e.g. the set of <binding> elements above
  • ElementName – used to denote a class as representing a build XML element

and the relevant NAnt classes are:

  • DataTypeBase – provides the abstract base class for NAnt types
  • Element – represents a build XML element

In simplified summary, to allow the XML snippet shown at the beginning of this post to be used, you will need to:

  • Create a class to represent the <binding> element, which derives from Element and is attributed with ElementName:
    [ElementName("binding")]
    public class IisBinding : Element
    {
        [TaskAttribute("type")]
        public string Type { get; set; }
    
        [TaskAttribute("ip")]
        public string IpAddress { get; set; }
    
        [TaskAttribute("port")]
        public int Port { get; set; }
    
        [TaskAttribute("host")]
        public string Host { get; set; }
    }
    
  • Create a data type that will represent a set of those <binding> elements. The crucial part is the BindingElements array. You’ll note that this class creates a representation of the IIS bindings (IisBindingDescription) from the elements in the array – you might just use the elements directly, depending on the scenario.
    [ElementName("bindings")]
    public class IisBindingSet : DataTypeBase
    {
        private readonly IList<IisBindingDescription> _bindings = new List<IisBindingDescription>();
    
        public IList<IisBindingDescription> Bindings
        {
            get { return _bindings; }
        }
    
        [BuildElementArray("binding")]
        public IisBinding[] BindingElements
        {
            set
            {
                foreach (var binding in value)
                {
                    ParseBinding(binding);
                }
            }
        }
    
        private void ParseBinding(IisBinding binding)
        {
            ...
    
            _bindings.Add(new IisBindingDescription(type, bindingInformation));
        }
    }
    
  • N.B. for completeness’ sake, this is the IisBindingDescription class – it’s just a DTO.
    public class IisBindingDescription
    {
        public string Protocol { get; private set; }
        public string Information { get; private set; }
    
        public IisBindingDescription(string protocol, string information)
        {
            Protocol = protocol;
            Information = information;
        }
    }
    
  • Add a property to your task with a BuildElement attribute, which unfortunately must also specify the name for the data type element – this must match the name used in the ElementName attribute used when creating the data type.
    [BuildElement("bindings")]
    public IisBindingSet Bindings { get; set; }
    

That’s all there is to it! Now, if you used the XML snippet from the top of this post in your build file, you would end up with two IisBindingDescription objects available in the Bindings property (and two elements in the BindingElements property, if you wanted to use them directly) of the IisBindingSet, which can be used where required.

It should be possible to use the BuildElementArray directly in your Task class, if you didn’t want a surrounding type. Also, there is a BuildElementCollection attribute, which I imagine acts very similarly to BuildElementArray but allows you to use a collection type instead.

32-bit registry sandboxing when running under a 64-bit machine

This is a definite gotcha. I was writing a NAnt task that uses the registry to check for the existence of certain installed programs. I hit a problem where when I ran the task directly, it worked fine, but when I ran it through NAnt, it failed.

Turns out this is because I’m using a 64-bit machine, so when running the task via an NUnit test, it was running in 64-bit mode, but when running using the 32-bit NAnt executable, Windows transparently redirects registry accesses to a different node called WOW6432Node (more information here). A lot of registry keys are shared (so I’d written similar NAnt tasks without issue), but some obviously end up being specific to 32-bit or 64-bit applications, and so might be found in the WOW6432Node but not in the normal node, or vice versa. Solution for me was obviously to check which keys existed in both so I could reliably check for a key regardless of which mode the task was running in.

Building .NET 4.0 applications with NAnt

You need to add a new framework configuration which (still?) doesn’t come by default with the download of NAnt. Insert the following into your NAnt.exe.config file (alongside the similar looking framework configurations):

<framework
  name="net-4.0"
  family="net"
  version="4.0"
  vendor="Microsoft"
  description="Microsoft .NET Framework 4.0"
  sdkdirectory="${path::combine(sdkInstallRoot, 'bin')}"
  frameworkdirectory="${path::combine(installRoot, 'v4.0.30319')}"
  frameworkassemblydirectory="${path::combine(installRoot, 'v4.0.30319')}"
  clrversion="4.0.30319">
  <runtime>
    <probing-paths>
      <directory name="lib/net/2.0" />
      <directory name="lib/net/neutral" />
      <directory name="lib/common/2.0" />
      <directory name="lib/common/neutral" />
    </probing-paths>
    <modes>
      <strict>
        <environment>
          <variable name="COMPLUS_VERSION" value="v4.0.30319" />
        </environment>
      </strict>
    </modes>
  </runtime>
  <reference-assemblies basedir="${path::combine(installRoot, 'v4.0.30319')}">
    <include name="Accessibility.dll" />
    <include name="mscorlib.dll" />
    <include name="Microsoft.Build.Engine.dll" />
    <include name="Microsoft.Build.Framework.dll" />
    <include name="Microsoft.Build.Utilities.dll" />
    <include name="Microsoft.Vsa.dll" />
    <include name="Microsoft.VisualBasic.dll" />
    <include name="Microsoft.VisualBasic.Compatibility.dll" />
    <include name="Microsoft.VisualBasic.Compatibility.Data.dll" />
    <include name="System.Configuration.dll" />
    <include name="System.Configuration.Install.dll" />
    <include name="System.Data.dll" />
    <include name="System.Data.OracleClient.dll" />
    <include name="System.Data.SqlXml.dll" />
    <include name="System.Deployment.dll" />
    <include name="System.Design.dll" />
    <include name="System.DirectoryServices.dll" />
    <include name="System.dll" />
    <include name="System.Drawing.Design.dll" />
    <include name="System.Drawing.dll" />
    <include name="System.EnterpriseServices.dll" />
    <include name="System.Management.dll" />
    <include name="System.Messaging.dll" />
    <include name="System.Runtime.Remoting.dll" />
    <include name="System.Runtime.Serialization.Formatters.Soap.dll" />
    <include name="System.Security.dll" />
    <include name="System.ServiceProcess.dll" />
    <include name="System.Transactions.dll" />
    <include name="System.Web.dll" />
    <include name="System.Web.Mobile.dll" />
    <include name="System.Web.RegularExpressions.dll" />
    <include name="System.Web.Services.dll" />
    <include name="System.Windows.Forms.dll" />
    <include name="System.Xml.dll" />
  </reference-assemblies>
  <task-assemblies>
    <!-- include MS.NET version-neutral assemblies -->
    <include name="extensions/net/neutral/**/*.dll" />
    <!-- include MS.NET 2.0 specific assemblies -->
    <include name="extensions/net/2.0/**/*.dll" />
    <!-- include MS.NET specific task assembly -->
    <include name="NAnt.MSNetTasks.dll" />
    <!-- include MS.NET specific test assembly -->
    <include name="NAnt.MSNet.Tests.dll" />
    <!-- include .NET 2.0 specific assemblies -->
    <include name="extensions/common/2.0/**/*.dll" />
  </task-assemblies>
  <tool-paths>
    <directory name="${path::combine(sdkInstallRoot, 'bin')}"
    if="${property::exists('sdkInstallRoot')}" />
    <directory name="${path::combine(installRoot, 'v4.0.30319')}" />
    <directory name="${path::combine(installRoot, 'v2.0.50727')}" />
    <directory name="${path::combine(installRoot, 'v3.0')}" />
    <directory name="${path::combine(installRoot, 'v3.5')}" />
  </tool-paths>
  <project>
    <readregistry
    property="installRoot"
    key="SOFTWARE\Microsoft\.NETFramework\InstallRoot"
    hive="LocalMachine" />
    <readregistry
      property="sdkInstallRoot"
      key="SOFTWARE\Microsoft\Microsoft SDKs\Windows\v6.0A\WinSDKNetFxTools\InstallationFolder"
      hive="LocalMachine"
      failonerror="false" />
    <readregistry
      property="sdkInstallRoot"
      key="SOFTWARE\Microsoft\Microsoft SDKs\Windows\v6.1\WinSDK\InstallationFolder"
      hive="LocalMachine"
      failonerror="false" />
    <readregistry
      property="sdkInstallRoot"
      key="SOFTWARE\Microsoft\Microsoft SDKs\Windows\v7.0\WinSDK\InstallationFolder"
      hive="LocalMachine"
      failonerror="false" />
  </project>
  <tasks>
    <task name="csc">
      <attribute name="supportsnowarnlist">true</attribute>
      <attribute name="supportswarnaserrorlist">true</attribute>
      <attribute name="supportskeycontainer">true</attribute>
      <attribute name="supportskeyfile">true</attribute>
      <attribute name="supportsdelaysign">true</attribute>
      <attribute name="supportsplatform">true</attribute>
      <attribute name="supportslangversion">true</attribute>
    </task>
    <task name="vbc">
      <attribute name="supportsdocgeneration">true</attribute>
      <attribute name="supportsnostdlib">true</attribute>
      <attribute name="supportsnowarnlist">true</attribute>
      <attribute name="supportskeycontainer">true</attribute>
      <attribute name="supportskeyfile">true</attribute>
      <attribute name="supportsdelaysign">true</attribute>
      <attribute name="supportsplatform">true</attribute>
      <attribute name="supportswarnaserrorlist">true</attribute>
    </task>
    <task name="jsc">
      <attribute name="supportsplatform">true</attribute>
    </task>
    <task name="vjc">
      <attribute name="supportsnowarnlist">true</attribute>
      <attribute name="supportskeycontainer">true</attribute>
      <attribute name="supportskeyfile">true</attribute>
      <attribute name="supportsdelaysign">true</attribute>
    </task>
    <task name="resgen">
      <attribute name="supportsassemblyreferences">true</attribute>
      <attribute name="supportsexternalfilereferences">true</attribute>
    </task>
    <task name="delay-sign">
      <attribute name="exename">sn</attribute>
    </task>
    <task name="license">
      <attribute name="exename">lc</attribute>
      <attribute name="supportsassemblyreferences">true</attribute>
    </task>
  </tasks>
</framework>

…and you can then set NAnt to use it using

<property name="nant.settings.currentframework" value="net-4.0" />