I had a problem recently in an application I was writing where I popped up a dialog box (jQuery Dialog) with a registration partial view. Once the user successfully registered, I checked to see if the request was an ajax request (Request.IsAjaxRequest()) and returned RedirectToAction to go to the home page. However, what ended up happening was this result was being shown in the Dialog box. As you can imagine, it was the full front page in the dialog, on top of the front page.

This was happening because the Ajax.BeginForm AjaxOptions UpdateTargetId was set and the result was being forced into that element regardless of the type of action being returned. To get around this I first returned a PartialRegistrationSuccess view that just said “Registration Successful. Please close this window and login”. I wasn’t very happy with this because without the AJAX request, the user was automatically logged in.

What I ended up doing was returning a partial login view that had a normal form on it (Html.BeginForm). This way, when the user logged in through the dialog box, the full page was redirected back to the home page on success, or a full login page on failure. This is much more graceful than the registration success message.

I use a lot of tools in my .NET development projects that I like to keep in my source control repository so all developers have the same version and mostly the same configuration. I do set up my projects so these can generally be overridden, but the build system uses the ones I keep in the repository for standards sake.

Recently I’ve been seeing a lot of tools released (specifically from Microsoft) that only come in .msi format. I don’t like this because it means I either have to install the msi (which then makes the tool dependent on my platform), or I have to extract the files and add them manually to my repository.

A quick Google search for “extracting msi files” revealed a really nice blog post Howto: extract files from a .msi file using the Windows command line . Go there and learn how to extract MSI files and then add them manually to a tools repository and link externally to this repository.

I had a hard time getting IIS 6 on my newly reformatted Windows XP Professional 64-bit to serve up ASP.NET applications. IIS was not installed by default, so I installed it through the normal control panel operations. Then I ran aspnet_regiis -ir, and figured that was that. When I added a virtual directory on the default site, I assigned the document root to where my ASP.NET website was located. When I went to the page however, it gave me a 404.

After searching around the internet for a while, I ran across a blog post at ILoggable about the issue. You have to go into IIS Manager and enable ASP.NET v2.0 as a Web Service Extension. After that, everything worked fine!

I am currently working on a Test Driven Development (TDD) Flickr API library in .NET. There already exists a FlickrNet library that is written in .NET, but it was written without using TDD and is very tightly coupled to the methods that send requests to flickr. I’ve tried refactoring the library but it just isn’t easy.

Instead I’m writing my own that I will share with others that is TDD driven. But that isn’t what this article is about. I’m writing today about Linq-to-Xml. Linq is basically an ORM technology for abstracting queries. You typically query a lot of data in programming such as XML, databases, files, and collections of information.

Linq allows you to look inside that data and pull out only what you need without having to write parsing methods. This is a gross over simplification of the process, but you can always read more at MSDN.

So why am I bringing this up? Well, the Flickr REST responses are all XML, so naturally my library has to do a lot of XML parsing. To test XML parsing, I have to pass in a bunch of XML somewhere, parse it  in my classes, and then do assertions that the objects I get back contain the same data that I sent in.

Originally my tests were looking something like this (FlickrBlogTests.cs):

[Test]
public void GetList_Returns_List_Of_Blogs() {
FlickrBlog blog1 = new FlickrBlog() { Id = “72″, Name = “Test Blog 1″, NeedsPassword = true, Url = “http://testblog1.com” };
string rawBlogResponse = “<blogs><blog id=\”" + blog1.Id + “\” name=\”" + blog1.Name +”\” … /></blogs>”;
List<FlickrBlog> blogs = FlickrBlogs.GetList();
Assert.That(blogs[0].Id, Is.EqualTo(blog1.Id));
}

Now, I started my actual code using Linq, so you will already see how Linq will come in handy. In the actual FlickrBlogs class code, I have a parse method like this:

private List<FlickrBlog> ParseResponseForBlogs(FlickrResponse response)
{
XDocument doc = XDocument.Load(new StringReader(response.RawData));
var query = from blog in doc.Elements(“blogs”).Elements(“blog”)
select new FlickrBlog
{
Id = blog.Attribute(“id”).Value,
Name = blog.Attribute(“name”).Value,
NeedsPassword = Convert.ToBoolean(blog.Attribute(“needspassword”).Value),
Url = blog.Attribute(“url”).Value
};
return query.ToList();
}

As you can tell, the test code is pretty shameful and difficult to change and test with. The FlickrBlogs code isn’t bad and it’s readable. Introducing Linq as a way to clean the test up:

[Test]
public void GetList_Correctly_Parses_Xml_Blog_Return()
{
FlickrBlog blog1 = new FlickrBlog() { Id = “73″, Name = “Bloxus Test”, NeedsPassword = true, Url = “http://remote.bloxus.com” };
FlickrBlog blog2 = new FlickrBlog() { Id = “74″, Name = “Test Blog 2″, NeedsPassword = false, Url = “http://testblog2.com” };
XDocument doc = new XDocument(
new XElement(“blogs”,
new XElement(“blog”,
new XAttribute(“id”, blog1.Id),
new XAttribute(“name”, blog1.Name),
new XAttribute(“needspassword”, blog1.NeedsPassword == true ? “1″ : “0″),
new XAttribute(“url”, blog1.Url)
),
new XElement(“blog”,
new XAttribute(“id”, blog2.Id),
new XAttribute(“name”, blog2.Name),
new XAttribute(“needspassword”, blog2.NeedsPassword == true ? “1″ : “0″),
new XAttribute(“url”, blog2.Url)
)
)
);

List<FlickrBlog> inputblogs = new List<FlickrBlog>();
inputblogs.Add(blog1);
inputblogs.Add(blog2);

FlickrResponse response = new FlickrResponse(FlickrResponseStatus.OK, doc.ToString());
commstub.Response = response;
List<FlickrBlog> blogs = flickr.Blogs.GetList();

Assert.That(commstub.Request.MethodName, Is.EqualTo(FlickrMethods.Blogs.GetList));
Assert.That(Is.Equals(blog1, blogs[0]));
Assert.That(Is.Equals(blog2, blogs[1]));
}
}

Robert Stackhouse wrote an excellent article on his blog titled Frameworks as a Means of Creating Transferrable Expertise. I started writing a response in the comments and ended up going off on quite a tangent. Thus, I’ve reposted parts of his article and my responses here, as well as some followup dialog.

It almost seems as if Microsoft and Sun and every other Framework author out there in the world figured out that training people is expensive, so let’s build a framework to reduce the cost of that training. It is much easier to spoon feed people than to teach them to think for themselves. Microsoft even went one step further and said, “Let’s go one better and try to get the poor schlep who doesn’t have 5 years experience to try to pay for the training themselves;let’s create a certification program.”

The alternative to Microsoft and Sun developing enterprise frameworks as large as .NET and Java is to have people still writing buffer overflows and string format vulnerabilities in C/C++. These frameworks have the huge benefit of making more secure code in many cases, as well as making it feasible for companies to even hire developers full time. If they figure that frameworks cut down development time, they are more likely to invest the money in IT in the first place, thus creating jobs for all of us.

I hardly think training is the issue here. If I had to chose between training someone to the point of proficiency in either .NET/Java or C/C++, I would chose a framework in a heartbeat. The time it would take for entry level programmers to learn C/C++ and the figure out how to be secure and develop worthwhile code would be prohibitive at best, and outright unfeasible at worst.

Certifications make sure people have basic skills and can as they claim. It all depends on the difficulty of the certification. I wouldn’t put much stock in someone with an MCP and little experience. Someone with an MCSD however I would give more attention, even if the relative experience wasn’t equal. The same goes for any IT sector – look at the Security+ (entry level) and the CISSP (serious professional).

Why is it that the same people who will ask every friend they have who the best mechanic in town is (instead of going straight to the Toyota dealer) will trust the word of a Microsoft certification over the word of a developer’s brethren or even his own code?

Again, this is context driven. Looking for a mechanic is a personal endevour that is something almost everyone deals with. Looking for a developer for a corporation is a different context entirely. By the same token, did you know that most of those dealerships won’t hire mechanics who don’t carry their companies certifications? Ford dealerships typically require a certification before they hire mechanics.

It again boils down to something akin to “you can at least perform at the minimum level we require, and we can teach you our development culture.” No two software projects are alike, but .NET is .NET, regardless of where it is used.

Granted not every development shop (even some of the ones who use Microsoft.NET) think this way. The only question is: would you rather have an employee who spends all day programing around the framework, or one that knows when to ditch the framework and look for another one or god forbid roll something from scratch?

The ones who know by instinct to ditch a framework for a more appropriate technology have most likely moved up the chain to a team lead position or management. I think we do have the problem of developers moving into management without having proper communication and management skills. We would almost never take a manager and say automatically that they would make a good developer, so why do we assume the opposite is true? Until our industry learns how to justify our software in the same manner that a machinist justifies a new lathe, we will always have this problem. I’ve seen this more times than I care to remember.

I also don’t really think we should be trying to optimize costs at a human level. Why don’t we instead invest in our employees, train them, and who knows maybe even wind up with a person who doesn’t hesitate to think for themselves and a little workplace loyalty in the end?

Again, look at it in context. Cost optimization at a human level goes on in every industry, not just software development. The salesman who sells two contracts a month will be replaced if he’s being compared to salesmen who sell 10 contracts a month. Can you guarantee that training him will ever pay off? This is the whole existance of HR and reorganization consultants. If you choose to ignore this area of optimization the organization may not recover and all the jobs will go away.

…all that being said, I agree that frameworks are not the holy grail. I think fast, core frameworks are the start and extensions to those are the way to go. There are jobs out there completely based on using things like Telerik controls, or Infragistics controls. These are build on top of a nice, extensible framework and they serve a purpose and create jobs. A company that would not be willing to develop that control themselves will be willing to pay for it and talent that can put it to efficient use for their purposes.

We are also still considered in the same boat as infrastructure services, which are not the same as software development. This is a fundamental flaw in my opinion. There are infrastructures (routers, servers, cabling, power) that is necessary AND a cost center. But software development produces “tangible” goods that can be used as a profit generator or at the very least an optimization of processes.

These are very different areas of IT but management still doesn’t separate them. We are getting closer with the advent of seperation between CIO/CTO, but few companies hire both. They are typically considered interchangable by uninformed upper management. Some even still put the CIO under the Finance department because they are seen as a cost center.

Sometimes I want to take a tool from one project that is under subversion and use it in another. The problem is with the existing .svn directories. Because the files are already in one repository, copying directly from there to another project will cause conflicts in the other repository.

There are quick and easy ways to solve this in both Windows and Linux. To get around this in Windows copy the directory to a temporary folder and use Windows find to search the directory for “.svn” and delete all the directories it finds. From there just move the folder to the new project and add it to source control.

On Linux it is even easier. Copy the folder to a temporar location and run “find . -type d -name .svn -exec rm -rf {}\;” . This will delete all .svn directories. Then move the tool directory to your new project and add it to source control.

I recently helped a friend out with the technical side of going “agile”. This meant setting up some project source control and automation for build and test. I have a pretty advanced automation setup on most of my projects right now. It’s far from perfect (I don’t have nightly releases being tagged, etc), but it gets the job done. But I sometimes forget how long it’s taken me to learn the lessons and get things set up correctly (AFAIK – I’m no expert). I may be missing a lot but I always try to improve what I’m doing and review it often for lessons learned.

As I said previously I had about 2 hours with my friend to set up an automated build, and teach him the virtues of Test Driven Development and Continuous Integration. We set up a project with a simple NAnt build file that had the basic targets – init, clean, compile, test, and build – and then got into some code with a 3 tier project (presentation, BLL, DAL) and a test project. This all went well and he caught on quickly which was nice. I sometimes have a hard time teaching things because the ideas are so ingrained into me that they are difficult to explain to others.

I raised a red flag with him because he was trying to introduce a lot of new technology at once. I asked him to really think about which technologies he wanted to implement and get started with. The obvious ones to start with are automated build (Ant/NAnt), unit testing (PHPUnit/NUnit), and Continuous Integration (phpUnderControl/CruiseControl.NET). Beyond this I asked him to wait until he was comfortable with these before adding things like an ORM he was unfamiliar with.

One of the worst things to do is jump into a new project with 100% new technologies that first have to be learned. We always want to play with the latest and greatest and there’s a good reason for many of them to exist. But taking on too much at once and not coming away with a good understanding of any of the technologies can also be harmful. Pick your new technologies for the value they will bring, not for the coolness factor.

The other side of this coin is that with a good automated build, testing, and continuous integration, later down the line it is much easier to introduce these new technologies that may have real benefits. Your code will be much more flexible, and your team will be much more comfortable switching out older technologies for new ones because the tests will tell the truth. And with a good source control setup, you can always branch new technology development and merge it later if the team deems it worthy enough to add into the mainline development.

I would like to write up a series of posts covering the very basics of the technical side of agile, with this post being the first. Agile development encompasses everything from technical issues to management to customer interaction. It can be difficult to jump into without knowing the how or the why of each part. There are also several different ways to implement agile development. But it is often easy to start with simple and sound technical practices. A grass roots technical movement can have a great effect on changing a teams culture. And, it’s usually easier to ask for forgiveness than permission, and definitely easier to ask for it when your project is wildly successful because of some small steps taken in the right direction.

Another good way to get involved with agile development is to find a local user group or a development shop that may be willing to have regular meetings with you to show you the ropes and review what you’re doing. My office has been good about allowing me to do this through community training and user group interaction. Part of the reason for this is that my projects are on sound foundations and they value the fact that I don’t waste time developing terrible code…

I recently had a little problem with my build scripts on my CI server. Since I have Visual Studio 2008 installed on my development machine, NAnt finds the Windows SDK v6.0A installed (flack from the VS2k8 install) and runs along happily building .NET 3.5 libraries (where I use WCF for SOA layers). However, when I recently created a new build server without installing Visual Studio, I kept getting these errors about the sdkInstallRoot not being found for net-3.5. I went ahead and downloaded and installed the latest Windows SDK for Vista (v6.1), but it had no effect on the build scripts.

I started digging into the blogosphere and found an article by Tim Barcz describing how to fix NAnt for .NET 3.5. This lead me to doing a little poking around in the NAnt.exe.config file, and I found the following registry key search:

<readregistry
property=”sdkInstallRoot”
key=”SOFTWARE\Microsoft\Microsoft SDKs\Windows\v6.0A\WinSDKNetFxTools\InstallationFolder”
hive=”LocalMachine”
failonerror=”false” />

The funny thing about that registry key is that it exists when you install Visual Studio, but not when you install the latest SDK. I did not want to alter the config file because on developer machines in a large team, you’re more likely to see Visual Studio installed than not. The above registry key is found then, and everything works. But for a build server where the basics are installed (CruiseControl.NET, Subversion, and the Windows SDK v6.1), this doesn’twork out so well.

What I ended up doing was creating a registry key on the build server that mimiced the above key, but actually pointed to the 6.1 SDK. Once NAnt can find the installed SDK path, it actually links to the proper libraries (usually found in C:\Windows\Micrsoft.NET\Framework\v3.5 and v3.0 respectively). This keeps the NAnt config file the same, thus sparing developers from having to modify their registry, and fixes the build server so it can compile against .NET 3.0 and 3.5 libraries.

The third post in this series on Automating Code Review tools will cover FxCop. FxCop is a coding standard and introspective analysis tool that looks at code using a ruleset and analyzes things such as code design (“should this method be static, internal, etc”) and performance (“change this method to static because it never uses the ‘this’ member”).

I have added FxCop to the automation on several projects I run and found out the hard way just what Microsoft thinks of my code. Actually, there were not a lot of code errors that were show stoppers. Most of the errors came from the Microsoft.Design and Microsoft.Performance rule sets of FxCop. I also had a strong naming error on all my libraries, which I fixed with some quick public/private keypair generation tools (more on this later).

So today’s post is about automating FxCop and fixing some of the likely rule violations you are going to see in your output. You can also follow the FxCop Blog at http://blogs.msdn.com/fxcop/.

FxCop Setup and NAntContrib

The first thing to do is download and install FxCop. FxCop is only available as an executable so you have to install it first and then copy the files it puts in the installation path you specify to your project’s tools directory. This process is pretty straight forward and there are no other dependencies you have to resolve to get FxCop working from your project repository without having it installed on the development computer you are working on.

The second thing to do (if you haven’t already) is download and install NAntContrib. NAntContrib contains a lot of useful tasks that NAnt does not, including the fxcop task. In my project’s repository I have FxCop in ${root.dir}\tools\FxCop and NAntContrib in ${root.dir}\tools\NAntContrib.

NAnt Build File Setup

First you have to make the NAntContrib tasks available to your build files. I use properties to specify paths in my projects so I can reuse them in submodules of my project. For this example, we will assume you have set these up, along with the properties set below. The following should be put at the top of your build right under the project element:

<property name=”root.dir” value=”.” />
<property name=”build.dir” value=”${root.dir}\build” />
<property name=”tools.dir” value=”${root.dir}\tools” />
<property name=”tools.nantcontrib.dir” value=”${tools.dir}\NAntContrib” />
<property name=”tools.fxcop.dir” value=”${tools.dir}\fxcop” />

<!– Load the NAntContrib Tasks –>
<loadtasks assembly=”${tools.nantcontrib.dir}\NAnt.Contrib.Tasks.dll” />

The Build Target

The next thing to do is define a build target that will compile your code. Before I added FxCop, here is what my build target looked like:

<target name=”build” depends=”clean,init” description=”Compiles the code into a DLL”>
<property name=”compile.dir” value=”${project::get-name()}.Source” />
<csc target=”library” output=”${build.dir}/${compile.dir}.dll” debug=”${debug.compile}”>
<sources>
<include name=”${compile.dir}/**/*.cs” />
</sources>
<references>
<!– Put necessary references here –>
</references>
</csc>
</target>

Setting Up the Environment for FxCop

Since we have loaded NAntContrib, the fxcop task is available to us, but we first have to do some setup. The fxcop task assumes that the FxCop executable (FxCopCmd.exe) is available from somewhere in your PATH environment variable. Since we removed it from Program Files, this is no longer true and we need to add the path to the FxCop directory to our PATH environment variable. We don’t want this to be permanent however since we don’t really want to mess with the environment any more than is necessary for our build to run. The following code should be placed under the properties and loadtask stuff we put in our build file earlier:

<!– FxCop PATH Resolution –>
<if test=”${not property::exists(‘setFxCopPath’)}”>
<setenv name=”PATH” value=”${environment::get-variable(‘PATH’)};${tools.fxcop.dir}” />
<property name=”setFxCopPath” value=”true” />
</if>

You don’t actually need the if statement when using only one build file. I put this in a global properties file that is loaded in each build file. However, I do not want the PATH variable to be inundated with the fxcop directory so I test to see if I’ve already loaded it or not.

Adding FxCop to Your Build File

The next stop of course is to actually run FxCop on your assemblies and see what happens. So, without further ado, here is the target:

<target name=”fxcop” depends=”build” description=”Runs the FxCop tool over the set of libraries”>
<fxcop>
<targets>
<include name=”${build.dir}\*.dll” />
</targets>
<arg value=”/out:${reports.dir}\fxcop.xml” /> <!– Change the directory where the output is saved –>
<arg value=”/directory:${lib.entlib.dir}” /> <!– Look in the entlib directory for supporting libraries used in the project –>
<!– <arg value=”/rid:-Microsoft.Design#CA2210″ /> – Example of ignoring a specific rule – Ignore the Strong Naming Rule –>
<arg value=”/fo” /> <!– Force output even if there are no violatons –>
</fxcop>
</target>

This target is running FxCop on the specified libaries in the build directory. It saves the output file to a specific location (which our CI server can save as an artifact). It also looks in a directory where other used libaries are located (in the case that they aren’t all in your build directory). Finally, I added a flag to force output even when there are no violations (/fo). This ensures a report artifact is generated without using a bunch of if statements in my CI’s NAnt file.

Another nice thing about FxCop that does not occur with CAT.NET is that it will fail the build automatically when it finds violations. When violations are found the return code from the command line utility is greater than 0 and NAnt will automatically fail the build unless you specify failonerror=”false”. Therefore, you don’t need a lot of extra build file code to check for errors with this utility.

Common Errors – Assembly Not Strongly Named

The first error I ran into was the strong naming error (rule Microsoft.Design#CA2210). Basically, Microsoft likes all of their assemblies to be strongly named (cryptographically signed with a private key). To get around this, we need to sign our assemblies. Finding information on how to do this can be a little tricky, but the jist of it is:

1. Open a Visual Studio 2005/2008 Command Prompt from the Start Menu (Start->Programs->Microsoft Visual Studio 2008->Visual Studio Tools->Visual Studio Command Prompt)
2. Change to your project directory (cd C:\Dev\Project1)
3. Run the command to generate a keyfile (sn.exe -k Project1.snk)
   1. You can also seperate the public/private key in the case where your private key is only available to a small group of people and others use the public key by running: sn -p Project1.snk PublicProject1.snk
4. Define a property in your project specifying the path to the keyfile (<property name=”assembly.keyfile” value=”${root.dir}\Project1.snk” />)
5. On your csc tasks add the following attribute: keyfile=”${assembly.keyfile}”

That’s it. Your assemblies will now be strongly named, and the violation will go away in FxCop. Obviously you may want to take this a step further and delay sign them and keep your private key available only in a secured location where deployment occurs.

Common Errors – Assembly Information Missing

The next error also deals with assembly attributes. When you define a new project in Visual Studio, it automatically adds an AssemblyInfo.cs file which contains things like the assembly title, description, copyright, keyfile, and more. there are a whole list of Assembly<Something>Attribute decorators you can use in your assembly. I have created a target that is called in all my compile targets right before I run csc that generates an AssemblyInfo.cs file for each project. The nice thing is that this lends itself to automating your versioning (another article) if you so choose. The target and an example of how I use it is below:

<target name=”GenerateAssemblyFile” description=”Generates an AssemblyInfo.cs File for inclusion in the compile methods”>
<asminfo output=”${compile.dir}\AssemblyInfo.cs” language=”CSharp”>
<imports>
<import namespace=”System” />
<import namespace=”System.Reflection” />
<import namespace=”System.EnterpriseServices” />
<import namespace=”System.Runtime.InteropServices” />
</imports>
<attributes>
<attribute type=”ComVisibleAttribute” value=”false” />
<attribute type=”CLSCompliantAttribute” value=”true” />
<attribute type=”AssemblyVersionAttribute” value=”${assembly.version}” />
<attribute type=”AssemblyTitleAttribute” value=”${assembly.title}” />
<attribute type=”AssemblyDescriptionAttribute” value=”${assembly.description}” />
<attribute type=”AssemblyCopyrightAttribute” value=”${assembly.copyright}” />
<attribute type=”ApplicationNameAttribute” value=”${assembly.name}” />
</attributes>
<references>
<include name=”System.EnterpriseServices.dll” />
</references>
</asminfo>
</target>

And the compile target that calls it:

<target name=”compile.models” depends=”init”>
<property name=”compile.dir” value=”${project::get-name()}.Models” />
<property name=”assembly.title” value=”Models Library” />
<property name=”assembly.description” value=”Models Library for the MVC framework” />
<property name=”assembly.name” value=”${project::get-name()}.Models” />
<call target=”GenerateAssemblyFile” />

<csc target=”library” output=”${build.dir}/${compile.dir}.dll” debug=”${debug.compile}” keyfile=”${assembly.keyfile}”>
<sources>
<include name=”${compile.dir}/**/*.cs” />
</sources>
<references>
<include name=”${build.base.dir}/.Services.Proxy.dll” />
</references>
</csc>
</target>

The target creates a bunch of properties to use in the GenerateAssemblyInfo target and then calls the genertion target. ${assembly.version} can be predefined, or you can use the NAntContrib ‘version’ task to automate the version number information.

Conclusion

FxCop is a great tool to help your team stick to recognized framework coding standards that include design time, performance, and security issues. It still does not replace a human code review and it should only be used to augment your code review processes.

Yesterday I posted about automating CAT.NET. Today while adding it to another build file, I ran across a great error! The tool did not detect any vulnerabilities in my code and therefore the XPath used in the xmlpeek task failed! This caused the build to fail with a false positive. I’ve updated my target to include the failonerror=”false” for the xmlpeek task and an if statement around the fail task that checks for the hasError property first. If it doesn’t exist the xmlpeek task did not find anything to put in the property and we do not need to fail the build.

Here is the new task:

<target name=”catnet” description=”Runs the CAT.NET static code analysis tool on a set of libraries”>
<exec program=”${root.dir}\Microsoft\CAT.NET\CatNetCmd.exe” workingdir=”.” output=”catnetout.log”>
<arg value=”/file:${build.dir}\${project::get-name()}.Models.dll” />
<arg value=”/file:${build.dir}\${project::get-name()}.Views.dll” />
<arg value=”/file:${build.dir}/${project::get-name()}.Presenters.dll” />
<arg value=”/file:${build.dir}/${project::get-name()}.Web.dll” />
<arg value=”/report:${reports.dir}\CatNetReport.xml” />
<arg value=”/reportxsloutput:${reports.dir}\CatNetReport.html” />
</exec>

<!– Check for errors since the command doesn’t throw error codes –>
<loadfile file=”catnetout.log” property=”catnetout” />
<fail if=”${string::contains(catnetout, ‘ERROR’)}” message=”There was an error running CAT.NET Static Analysis” />
<!– Clean up if we didn’t error out –>
<delete file=”catnetout.log” />

<xmlpeek file=”${reports.dir}\CatNetReport.xml”
property=”hasErrors”
xpath=”//Rule[TotalResults>0]/Results/Result/ProblemDescription” failonerror=”false” />
<if test=”${property::exists(‘hasErrors’)}”>
<fail if=”${string::get-length(hasErrors) &gt; 0}” message=”CAT.NET found at least one problem: ${hasErrors}” />
</if>
</target>