Numbers and Booleans

C# offers a dozen numeric types. You will use four of them regularly, and the choice between them comes down to three questions: how large can the value get, how exact does it need to be, and what should happen at the edges.

Getting this wrong does not usually produce an error. It produces a number that looks reasonable and is not.

int totalSeats = 7;
int rows = 2;

int seatsPerRow = totalSeats / rows;          // 3, not 3.5
int leftOver = totalSeats % rows;             // 1

decimal exact = (decimal)totalSeats / rows;   // 3.5

Console.WriteLine($"{seatsPerRow} per row, {leftOver} left over, exact {exact}");

• When both sides of / are whole numbers, C# performs whole-number division and throws the remainder away. It does not round: 7 / 2 is 3, and 9 / 10 is 0.
• The % operator gives you the remainder that division dropped.
• Converting one side to decimal makes the whole expression decimal, so the fraction survives. Converting the result instead is too late — the information has already gone.

double loose = 0.1 + 0.2;
Console.WriteLine(loose);          // 0.30000000000000004
Console.WriteLine(loose == 0.3);   // False

decimal tight = 0.1m + 0.2m;
Console.WriteLine(tight);          // 0.3
Console.WriteLine(tight == 0.3m);  // True

• decimal stores digits in base 10, so a value you typed as 0.1 stays 0.1 and comparisons behave the way a person expects.
• The cost is speed and range. decimal arithmetic is several times slower than double and covers a smaller span of magnitudes. For money that trade is worth making every time.
• The m suffix is not decoration. Without it the literals are doubles, and assigning a double result to a decimal variable is a build error — which is C# stopping you mixing the two by accident.
• Comparing two doubles with == is rarely what you want. Compare the difference against a tolerance you choose, or use decimal if exactness is the requirement.

int bytesToday = int.MaxValue;     // 2,147,483,647

int wrapped = bytesToday + 1;
Console.WriteLine(wrapped);         // -2147483648

try
{
    int guarded = checked(bytesToday + 1);
    Console.WriteLine(guarded);
}
catch (OverflowException)
{
    Console.WriteLine("Overflow reported instead of wrapping.");
}

• Adding 1 to the largest int wraps around to the smallest. There is no exception and no warning — the extra bit has nowhere to go, so the sign flips.
• checked turns that wrap into an OverflowException, which is far easier to diagnose than a nonsensical negative total.
• A whole project can be switched to checked arithmetic with CheckForOverflowUnderflow in the project file. Most teams leave the default and choose a type with room to spare instead.