Control Flow and Method Contracts

Branches encode ordered policy

An if condition must be Boolean. Relational comparisons express a domain boundary, while && and

short-circuit and can protect a later operation. Parentheses control expression grouping; they do not justify packing unrelated state changes into one clever expression. Keep validation and mutation easy to inspect.

An else-if chain selects the first matching branch, so overlapping thresholds must appear in a deliberate order. A switch statement or switch expression can express alternatives, including patterns, but must still define how invalid or unmatched domain values are handled. A default arm is a policy, not permission to ignore missing requirements.

Test adjacent threshold values

The first program classifies a known score after validating its permitted interval. The highest threshold is tested first. For score74, high fails and pass succeeds. A real input reader should feed this domain function rather than mixing terminal parsing into every branch.

Test immediately below, exactly at, and immediately above each threshold. The difference between >= and > often hides when tests use only typical middle values. Keep invalid-score rejection separate from ordinary retry classification so a score outside zero through one hundred is not accidentally treated as a valid category.

using System;

int score = 74;
if (score < 0 || score > 100)
{
    Console.WriteLine("invalid");
}
else if (score >= 85)
{
    Console.WriteLine("high");
}
else if (score >= 60)
{
    Console.WriteLine("pass");
}
else
{
    Console.WriteLine("retry");
}

pass

A loop needs a valid starting state and progress

Before each iteration, state which work is already complete. For a sum of one through five, total initially represents an empty sum. Before iteration i it contains all earlier positive integers, and adding i preserves that claim for the next iteration. Increasing i reaches a condition that becomes false.

Use half-open ranges for indexed collections: zero through Count minus one. for, while, and foreach have different syntax but the same obligations for bounds, valid state, and termination. break and continue change control flow, so include those paths when an iteration owns resources or maintains several counters.

Pass values and report success explicitly

Ordinary parameters receive copied values. Copying an object reference still lets a method reach the same object, while reassigning the local reference does not reassign the caller’s variable. ref explicitly aliases a caller variable; out requires assignment before normal return. These features express different contracts, not a single general pass-by-reference default.

The second example implements a small Try-style helper using out. Its documented domain is nonnegative operands whose sum fits int. It assigns the output on every return path, checks before addition, and returns false on failure. C# out does not promise unchanged output on failure, so callers must use the Boolean result.

using System;

if (TryAddNonnegative(12, 8, out int result))
{
    Console.WriteLine($"result={result}");
}

static bool TryAddNonnegative(int a, int b, out int result)
{
    result = 0;
    if (a < 0 || b < 0 || a > int.MaxValue - b) return false;
    result = a + b;
    return true;
}

result=20

Keep dependencies and scope visible

A method contract should state accepted inputs, effects, result meaning, and failure policy. Prefer parameters over hidden mutable globals when that improves testability. Local functions can keep a helper near its use, but capturing outer variables introduces dependencies that deserve review. Overloads should have distinct meaningful shapes instead of surprising conversions.

Recursion needs a base case and progress, and the runtime does not promise unlimited stack depth. For large or externally supplied work, an iterative algorithm with explicit limits may be easier to justify. Short methods are useful when they clarify responsibilities, not when they scatter one invariant across many hidden state changes.