Rash thoughts about .NET, C#, F# and Dynamics NAV.

In this tutorial I will describe how you can set up a complete build infrastructure with “FAKE – F# Make”. You will learn:

• How to automatically compile your C# or F# projects
• How to automatically run NUnit UnitTests on your projects
• How to zip the output to a deployment folder

Install F#

“FAKE – F# Make” is completely written in F# and all build scripts will also be written in F#, but this doesn’t imply that you have to learn programming in F#. In fact the “FAKE – F# Make” syntax is hopefully very easy to learn. But if you need to you can use the complete power of F# and the .NET Framework.

But in order to get things working we need to install the F# environment. You can download the F# April 2011 CTP from the Microsoft F# Developer Center or install Visual Studio 2010.

Download Calculator Sample

Now download the latest CalculatorSample-*.zip from the FAKE Download site. This sample includes 3 tiny projects and basically the following structure:

• src\app
  • Calculator (Command line)
  • CalculatorLib (Class library)
• src\test
  • Test.CalculatorLib (NUnit test library)
  • xUnit.Test.CalculatorLib (xUnit test library)
• tools
  • FAKE Assemblies
  • NUnit
• build.bat
• build.fsx
• completeBuild.bat
• completeBuild.fsx
• Calculator.sln

Getting “FAKE – F# Make” started

If you run the build.bat from the command line then your first FAKE script (build.fsx) will be executed. If everything works fine you will get the following output:

Now open the build.fsx with Visual Studio. It should look like this:

As you can see the code is really simple. The first lines include the FAKE library and are vital in all FAKE build scripts.

After this header the Default target is defined. A target definition contains of two important parts. The first is the name of the target (here “Default”) and the second is an action (here a simple trace of “Hello world”). The Action can be defined as simple lambda expressions or as methods.

The last line runs the “Default” target – which means it executes the defined action of the target.

Cleaning the last build output

A typical first step in most every build scenario is to clean the output of the last build. We can achieve this by modifying the build.fsx to the following:

We introduced some new concepts in this snippet. At first we defined a global property called “buildDir” with the relative path of a temporary build folder.

In the Clean target we use the CleanDir task to clean up this build directory. This simply deletes all files in the folder and creates the directory if necessary.

In the dependencies section we say that the Default target is dependent of the Clean target. In other words Clean is a prerequisite of Default and will be run before the execution of Default:

Building the application

In the next step we want to compile our application libraries, which means we want to compile all projects under /src/app with MSBuild.

We defined a new build target named “BuildApp” which compiles all project files given in the property appReferences with the MSBuild task and the build output will be copied to buildDir.

In order to find the right project files “FAKE – F# Make” scans the folder src/app/ and all subfolders with the given pattern. Therefore a similar FileSet definition like in NAnt or MSBuild (see project page for details) is used.

In addition the target dependencies are modified again. Now Default is dependent of BuildApp and BuildApp needs Clean as a prerequisite.

This means the execution order is: Clean ==> BuildApp ==> Default.

Building Test projects

Now our main application will be built automatically and it’s time to build the test application. We use the same concepts as before:

This time we defined a new target “BuildTest”, which compiles all C# projects below src/test/ in Debug mode and we put the target into our build order.

Testing the test assemblies with NUnit

Now all our projects will be compiled and we can use the NUnit task in order to let NUnit test our assembly:

Our new target “Test” scans the test directory for test assemblies and runs them with NUnit. The mysterious part (fun p –> …) simply overrides the default parameters of the NUnit task and allows to specify concrete parameters..

Deploying a zip file

Now we want to deploy a *.zip file containing our application:

The new target “Deploy” scans the build directory for all files. The result will be zipped to \deploy\Calculator.zip via the Zip task.

What’s next?

Now you are ready to write your own “FAKE – F# Make” build scripts. If you have any questions or suggestions feel free to comment on this post.

In the next article I will show how we can add FxCop to our build in order to check specific naming rules.