What are bits and bytes, how big are the .NET numeric types, and what happens when an int overflows?

1. How two's complement works (8-bit example)

  +5  = 0000 0101
  invert -> 1111 1010
  add 1  -> 1111 1011  = -5

  0111 1111 = +127  (sbyte.MaxValue)
  1000 0000 = -128  (sbyte.MinValue)
  127 + 1 -> 1000 0000 -> wraps to -128

The top bit is the sign bit. Adding 5 + (−5) in binary gives 1 0000 0000; the carry falls off the top, leaving 0. That's why hardware needs only one adder.

2. Where overflow bites

3. Checked versus unchecked in practice

• Unchecked is the default because overflow checks add a compare and branch to arithmetic in hot loops.
• Turning on CheckForOverflowUnderflow for Debug builds only is a common way to catch bugs in tests without paying the cost in Release. Decide deliberately: behaviour then differs between configurations.
• Generic maths (INumber<T>) has T.CreateChecked, CreateSaturating and CreateTruncating for explicit conversion behaviour.

4. Bit manipulation patterns

set bit n:      x |=  (1 << n)
clear bit n:    x &= ~(1 << n)
toggle bit n:   x ^=  (1 << n)
test bit n:     (x & (1 << n)) != 0
lowest set bit: x & -x
power of two:   x > 0 && (x & (x - 1)) == 0   (or BitOperations.IsPow2)

Shifts in C# mask the count: for int, x << 33 is the same as x << 1, because only the low five bits of the count are used.

5. Flags enums

A [Flags] enum gives each value its own bit so several can be combined in one integer. Use powers of two (or 1 << n), include None = 0, and test with HasFlag or (value & Flag) == Flag. ToString() prints combinations such as Read, Write.

6. bool is a byte, and why that matters

A bool uses a whole byte (and four bytes in some interop contexts). Storing a million flags as bool[] uses about 1 MB; BitArray or a ulong[] bitmap uses about 125 KB. For hot data, smaller means more fits in CPU cache.

7. Try it yourself

1. Print int.MaxValue + 1 in an unchecked block and in a checked block, and explain both results.
2. Write a method that returns the number of set bits in a uint with a loop, then compare it with BitOperations.PopCount in BenchmarkDotNet.
3. Create a [Flags] enum Permissions { None = 0, Read = 1, Write = 2, Delete = 4 }, combine values, print them, and remove one with &= ~.
4. Turn on <CheckForOverflowUnderflow> for Debug in a test project and write a test that proves your summing code throws instead of wrapping.

namespace BitsAndBytes;

using System.Numerics;

[Flags]
public enum Permissions
{
    None = 0,
    Read = 1 << 0,
    Write = 1 << 1,
    Delete = 1 << 2,
}

public static class Program
{
    public static void Main()
    {
        Console.WriteLine($"int is {sizeof(int)} bytes, range {int.MinValue}..{int.MaxValue}");

        int max = int.MaxValue;
        int wrapped = unchecked(max + 1);
        Console.WriteLine(wrapped);                      // -2147483648

        try
        {
            int boom = checked(max + 1);
        }
        catch (OverflowException ex)
        {
            Console.WriteLine($"checked: {ex.Message}");
        }

        // Safe midpoint for large indexes
        int lo = 2_000_000_000, hi = 2_100_000_000;
        int mid = lo + (hi - lo) / 2;
        Console.WriteLine(mid);

        // Money: never sum cents in an int
        long totalCents = 0;
        foreach (var cents in new long[] { 1_500_000_000, 1_500_000_000 })
        {
            totalCents = checked(totalCents + cents);
        }
        Console.WriteLine(totalCents);

        var perms = Permissions.Read | Permissions.Write;
        perms &= ~Permissions.Write;
        Console.WriteLine(perms);                        // Read

        Console.WriteLine(BitOperations.PopCount(0b1011_0001u)); // 4
        Console.WriteLine(BitOperations.IsPow2(64));            // True
    }
}