Introduction

I found the article about code contracts in this month's MSDN very exciting. I was unaware of this feature of .NET 4.0 before reading the article, and as the manager of a team of developers who maintain a very large and complex application, I am always interested in techniques that improve code quality and correctness. I won't rehash the interesting details about code contracts in this article. Go read the MSDN article first or this CodeProject introduction. The basics are all there. Then go here to the Microsoft DevLabs page with the download you'll need to run the code below.

My first thought when reading the MSDN article was that the benefits must come at some price, and my initial concern was an impact on performance. Contracts are enforced at run-time by inserting custom code at compile time, and whenever some other process is adding code to mine, I worry about hidden performance costs.

I wrote the small app below to get some metrics and assess how expensive contracts are compared to the other techniques that can be used to validate pre and post execution conditions.

Using the Code

The author of the MSDN article used a trivial calculator function to highlight the benefits of contracts. I'll use the same basic function here:

The extra if statement in there is just to reinforce the difficulty of adding post-condition checking everywhere in your code where you have premature exits. I'm going to leave it here for the analysis.

"If-Then-Throw"

One way to check pre and post conditions is to use explicit if statements to validate your input parameters and output results. All of the pre and post conditions we're adding here are perfectly arbitrary, but will naturally be consistent in all the examples.

The Setup

I ran the application 5 times to get average times and a feel for the variability of the results. The tests were executed on Windows 7 (32-bit), on a dual core (Intel Core 2 E8400 3.0GHz) CPU with 4Gb of RAM.

I used version 1.4.40314.1 of the code contracts SDK with pre and post contract checking enabled.

I'm not interested in the performance of the different methods of execution when the pre or post conditions are not met, just the overhead of the different validation frameworks.

The Results

Debug

Add

If-then-throw

Assert

Contract

Run 1 (ms)

1934.4

2199.6

2230.8

3213.6

Run 2

1950.0

2184.0

2215.2

3244.8

Run 3

1950.0

2199.6

2246.4

3260.4

Run 4

1950.0

2246.4

2293.2

3369.6

Run 5

1934.4

2184.0

2246.4

3244.8

Average

1940.6

2202.7

2246.4

3266.6

Std Dev

8.54

25.63

29.18

60.01

13.5%

1.98%

45.42%

15.76%

68.33%

Table 1. Results from running code in Visual Studio 2008 built for debug.

The "naked" calculator method took on average 1940.6ms to execute.

The method with the if-then-throw pre and post condition checking took 2202.7ms to execute (13.5% slower than the unchecked benchmark Add() method).

The method that used Debug.Assert() pre and post condition checking took 2246.4ms, (1.98% slower than if-then-throw and 15.76% slower than the unchecked benchmark Add() method).

The method that used contracts took on average 3266.6ms and was 45.42% slower than Debug.Assert() and 68.33% slower than the "naked" calculator method.

When the switch to enable contract code insertion is set to false, the ContractCheckedAdd() method took exactly the same amount of time as the unchecked Add() method, as no code was inserted at compile time. You can verify that by looking at the IL of ContractCheckedAdd() in an assembly built with contracts enabled and contracts disabled. ContractCheckedAdd() looks the same as Add() when contracts are not enabled.

Conclusion

I hope to avoid maintenance headaches on future projects and would be happy to sacrifice some performance for some assurances about correctness, so I expect to use code contracts in a lot of my future development. I thought it would be good to know some of the costs to weigh against the benefits.

Comments and Discussions

Any reason why you're not testing with, or including an additional test with the Requires<T> override? I know the VSM article used the override (which throws a new instance of T on failure) but noticed your article just uses the vanilla mechanism. With the exception override, your contracts will still be tested in ReleaseRequires builds (a CC setting under Runtime Checking) but will just throw the exception and nothing else (IIRC).