Code Contracts and Precondition Checks in C

This article provides an overview of code contracts in C#, focusing specifically on how precondition checks establish software reliability. You will learn the core philosophy behind the Design by Contract approach, how precondition checks ensure methods receive valid inputs before execution, and the transition from the legacy System.Diagnostics.Contracts library to modern C# validation techniques.

What Are Code Contracts?

Code contracts are software engineering constructs based on the "Design by Contract" methodology developed by Bertrand Meyer. The concept treats the interaction between a caller and a callee as a formal agreement. A software component guarantees specific behavior only if the calling code satisfies certain obligations.

In .NET, code contracts define programmatic specifications directly within source code through three primary mechanisms:

1. Preconditions: Requirements that must be true before a method can execute.
2. Postconditions: Guarantees that must be true when a method finishes execution.
3. Object Invariants: Conditions that must remain true throughout the entire lifetime of an object instance, except while an internal state transition is occurring.

Code contracts serve as both living documentation and automated verification tools, catching software defects during static analysis, runtime execution, and unit testing.

How Precondition Checks Work

A precondition is an upfront assertion about the state of the program and the parameters supplied by the caller. If a caller fails to satisfy a precondition, the method should not proceed, because the fundamental assumptions required for correct execution are not met. In contract terminology, a precondition failure indicates a bug in the calling code, not in the receiving method.

When a precondition check executes:

• It evaluates a boolean condition containing method arguments or object state.
• If the condition evaluates to true, the method execution proceeds normally.
• If the condition evaluates to false, the contract is violated, halting execution immediately by triggering a failure handler or throwing an exception (typically an ArgumentException or ArgumentNullException).

Implementing Preconditions in C

1. Legacy Approach: System.Diagnostics.Contracts

Historically, .NET Framework 4.0 introduced native support via the System.Diagnostics.Contracts namespace using the static Contract.Requires method.

using System.Diagnostics.Contracts;

public class BankAccount
{
    public decimal Balance { get; private set; }

    public void Deposit(decimal amount)
    {
        // Precondition check
        Contract.Requires(amount > 0, "Deposit amount must be positive.");

        Balance += amount;
    }
}

This implementation required a binary rewriter (CCRewrite) to inject runtime checks or perform static verification. Because the tooling lacked ongoing maintenance and integration issues arose with newer compilers, this specific framework is rarely used in modern .NET development.

2. Modern C# Precondition Checks (Guard Clauses)

Modern C# applications implement precondition checks using explicit validation patterns and built-in runtime guard methods.

Explicit Guard Clauses

Prior to recent .NET versions, developers explicitly wrote if conditions to throw standard exceptions:

public void ProcessOrder(string orderId, decimal total)
{
    if (string.IsNullOrWhiteSpace(orderId))
    {
        throw new ArgumentException("Order ID cannot be null or empty.", nameof(orderId));
    }

    if (total <= 0)
    {
        throw new ArgumentOutOfRangeException(nameof(total), "Total must be greater than zero.");
    }

    // Core logic proceeds here
}

Modern Built-In Guard Methods (.NET 6+)

Modern .NET versions provide high-performance, standardized static methods that streamline precondition verification:

public void UpdateUser(string username, UserProfile profile)
{
    // Modern precondition checks
    ArgumentException.ThrowIfNullOrWhiteSpace(username);
    ArgumentNullException.ThrowIfNull(profile);

    // Core logic proceeds here
}

3. Compile-Time Preconditions with Nullable Reference Types

Starting in C# 8.0, nullable reference types allow developers to enforce null-check preconditions at compile time rather than relying strictly on runtime checks:

#nullable enable

public void PrintName(string name) // Compiler warns if caller passes a null reference
{
    Console.WriteLine(name.Length);
}

While compile-time warnings help eliminate null-related defects during development, combining them with runtime guard clauses remains the standard practice for public APIs and critical boundary checks.