Operators in Depth

Arithmetic and comparison work the way you would expect. The parts of this topic that produce real bugs are precedence — which operator binds tighter — and the operators C# has for dealing with missing values.

decimal subtotal = 240m;
decimal shipping = 4.99m;

subtotal += shipping;          // same as subtotal = subtotal + shipping
subtotal *= 1.20m;             // add 20 per cent VAT

int itemsToPick = 3;
int picked = 0;

while (picked < itemsToPick)
{
    picked++;                  // one clear job on its own line
}

int minutesTotal = 135;
int hours = minutesTotal / 60;      // 2
int minutes = minutesTotal % 60;    // 15

Console.WriteLine($"{subtotal:N2} due, {picked} picked, {hours}h {minutes}m spent");

• Compound assignment reads the variable once and writes it once, which is shorter and harder to get wrong than repeating the name.
• Division and remainder together split a value into units: 135 minutes is 2 hours and 15 minutes.
• picked++ adds one. Used inside a bigger expression it also has a value — the old one for picked++, the new one for ++picked — which is a distinction not worth relying on. Keep it on its own line.

decimal price = 40m;
decimal? discount = null;

decimal wrong = price - discount ?? 0m;      // 0
decimal right = price - (discount ?? 0m);    // 40

Console.WriteLine($"wrong: {wrong}, right: {right}");

• Subtraction binds tighter than ??, so the first line is read as (price - discount) ?? 0m.
• price - discount has type decimal? and is null whenever discount is null, so the fallback replaces the whole calculation rather than the missing discount.
• The customer is charged nothing, and no exception is raised. The test that would catch it is the one where a customer has no discount.
• Brackets cost two characters. Add them any time ?? shares an expression with arithmetic.

Employee? manager = null;   // as though the lookup found nobody

if (manager is not null && manager.IsActive)
{
    Console.WriteLine($"Approver: {manager.Name}");
}

string displayName = manager?.Name ?? "Unassigned";
int approvals = manager?.ApprovalCount ?? 0;

string? note = null;
note ??= "No handover note supplied";

Console.WriteLine($"{displayName}, {approvals} approvals. {note}");

public class Employee
{
    public string Name { get; set; } = "";
    public bool IsActive { get; set; }
    public int ApprovalCount { get; set; }
}

• && stops as soon as the left side is false, so manager.IsActive is never reached when manager is null. Without that guarantee this condition would throw.
• & and | do not short-circuit: both sides always run. That matters when the right side can throw or changes something, and it is rarely what you want in a condition.
• manager?.Name gives null when manager is null instead of throwing, and ?? then supplies the fallback. The pair replaces several lines of null checking.
• ??= assigns only when the left side is currently null, which is a tidy way to fill in a default without an if.