Understanding and Using C#'s `checked` and `unchecked` Keywords for Integer Overflow Handling

Learn how to control integer overflow and underflow behavior in C# using the `checked` and `unchecked` keywords. This tutorial explains their impact on exception handling and performance, providing guidance on choosing the appropriate approach for safe and efficient integer arithmetic.

Understanding `checked` and `unchecked` in C# for Integer Overflow Handling

Introduction

In C#, the `checked` and `unchecked` keywords control how integer overflow and underflow exceptions are handled. Integer overflow occurs when the result of an arithmetic operation exceeds the maximum value representable by the integer type. Underflow is the analogous situation for the minimum value.

The `checked` Keyword

The `checked` keyword explicitly enables overflow checking. When an arithmetic operation within a `checked` context results in an overflow, an `OverflowException` is thrown, halting program execution. This helps catch potential errors during development.

Example 1: Overflow without `checked`

using System;

class Program {
    static void Main(string[] args) {
        int val = int.MaxValue;
        Console.WriteLine(val + 2); // Overflow occurs, but no exception is thrown
    }
}

-2147483647 // Incorrect result due to overflow
        

Example 2: Overflow with `checked`

using System;

class Program {
    static void Main(string[] args) {
        checked {
            int val = int.MaxValue;
            Console.WriteLine(val + 2); // OverflowException is thrown
        }
    }
}

Unhandled Exception: System.OverflowException: Arithmetic operation resulted in an overflow.
        

The `unchecked` Keyword

The `unchecked` keyword disables overflow checking. When an arithmetic operation within an `unchecked` context overflows, the result is truncated (the most significant bits are discarded), potentially leading to unexpected or incorrect results. This is generally faster but less safe.

Example 3: Overflow in `unchecked` Context

using System;

class Program {
    static void Main(string[] args) {
        unchecked {
            int val = int.MaxValue;
            Console.WriteLine(val + 2); // Overflow, result truncated
        }
    }
}

-2147483647 // Incorrect result due to overflow
        

Conclusion

The `checked` and `unchecked` keywords provide control over overflow handling. `checked` is generally preferred for safety during development to catch potential errors early. `unchecked` can be used for performance optimization in situations where overflow is unlikely or acceptable.