We use
NAnt to automate our build process, and right now I'm working on refactoring the build that my group uses for continuous integration. One of the things I noticed is that when our product builds, the main build file "includes" a few other build files and executes targets from them. One of the build files that gets included only ever has one target called, and it does a bunch of internal work to get a lot of things done. It looks a lot like this:
Notice how there's only one entry point in the external build file and the tasks inside call other tasks, some of which are common, almost like NAnt "functions" that pass parameters by setting properties. Not only that, but part of the build output for the product is to include this build script so other products can include it and use it in the same way. I don't know about you, but this says "custom NAnt task" to me.
In converting this to a custom NAnt task, I found that part of what the script was doing was calling other custom NAnt tasks. Not wanting to replicate all of the functionality of these other custom NAnt tasks, I figured I'd write my custom task to call the other tasks programmatically.
Interestingly enough, this isn't as straightforward as you might think, and NAnt documentation on this is, well,
light. You can't just create the task object and call it, you actually have to give the created task some context about the environment it's working in. You do this by calling the
CopyTo method on the task object. By and large, the way it looks is this:
using System;
using NAnt.Core;
using NAnt.Core.Attributes;
using NAnt.Core.Tasks;
namespace MyCustomNAntTasks {
[TaskName("customtask")]
public class MyCustomTask : Task {
protected override void ExecuteTask() {
this.Log(Level.Info, "Starting custom task...");
// Create and execute a <tstamp /> task
this.Log(Level.Verbose, "Executing a tstamp task...");
TStampTask tstamp = new TStampTask();
this.CopyTo(tstamp);
tstamp.Execute();
// Create and execute a <sysinfo /> task
this.Log(Level.Verbose, "Executing a sysinfo task...");
SysInfoTask sysinfo = new SysInfoTask();
this.CopyTo(sysinfo);
sysinfo.Execute();
this.Log(Level.Verbose, "Executing custom work...");
// TODO: Insert your custom task's work here
this.Log(Level.Info, "Custom task complete.");
}
}
}
That seems to work well for most tasks. Some tasks require more initialization than just
CopyTo, like the setting of properties or what-have-you, so you'll need to set that stuff up for things to work since you don't get the validation benefits that you get when NAnt parses the build script and tells you when you're missing required values.
One task I haven't gotten to work like this is the
<csc /> task - for some reason, I haven't figured out how to properly add references to the task to get it to work. Instead of calling
<csc />, I ended up writing a quick method using the
Microsoft.CSharp.CSharpCodeProvider to compile things directly.
Minor update: I actually ended up having to use an
<exec /> task to build the code rather than the
Microsoft.CSharp.CSharpCodeProvider because I didn't see a way with the code provider to specify a target framework, whereas you can call the framework-specific
csc.exe based on NAnt project settings and the correct framework will be used.