Checked And Unchecked Keywords In C# Complete Guide

Understanding checked and unchecked Keywords

In C#, arithmetic operations that could potentially overflow or underflow are allowed by default. However, C# provides the checked and unchecked keywords to control overflow checking.

• Checked: This keyword helps in catching potential overflow or underflow conditions. If an overflow or underflow occurs within a checked context, an OverflowException is thrown.

• Unchecked: This keyword allows you to suppress overflow checking. Operations within an unchecked context do not throw exceptions even if they cause overflows.

Example Step-by-Step

Let's walk through an example to illustrate how to use checked and unchecked in C#.

Step 1: Setting Up Your Environment

First, ensure you have C# development environment ready. You can use Visual Studio, Visual Studio Code with the C# extension, or any other C# compatible IDE.

Step 2: Create a New C# Console Application

You can create a new console application in your IDE. Here’s the code for a simple demonstration.

using System;

namespace CheckedUncheckedExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Step 3: Demonstrating the unchecked keyword
            Console.WriteLine("Demonstrating unchecked keyword...");
            unchecked
            {
                int maxInt = int.MaxValue;
                int nextInt = maxInt + 1;
                Console.WriteLine($"Result of {maxInt} + 1 is {nextInt}");
            }

            // Step 4: Demonstrating the checked keyword for addition
            Console.WriteLine("\nDemonstrating checked keyword for addition...");
            try
            {
                int maxInt = int.MaxValue;
                int nextInt = checked(maxInt + 1); // This will throw an exception
            }
            catch (OverflowException ex)
            {
                Console.WriteLine($"Exception caught: {ex.Message}");
            }

            // Step 5: Demonstrating the checked keyword for subtraction
            Console.WriteLine("\nDemonstrating checked keyword for subtraction...");
            try
            {
                int minInt = int.MinValue;
                int prevInt = checked(minInt - 1); // This will throw an exception
            }
            catch (OverflowException ex)
            {
                Console.WriteLine($"Exception caught: {ex.Message}");
            }

            // Step 6: Using checked and unchecked in a larger scope
            Console.WriteLine("\nUsing checked and unchecked in a larger scope...");
            checked
            {
                int largeValue = 2100000000;
                int multiplier = 10;
                try
                {
                    int result = largeValue * multiplier; // This might overflow
                    Console.WriteLine($"Result of {largeValue} * {multiplier} is {result}");
                }
                catch (OverflowException ex)
                {
                    Console.WriteLine($"Exception caught: {ex.Message}");
                }
            }

            unchecked
            {
                int largeValue = 2100000000;
                int multiplier = 10;
                int result = largeValue * multiplier; // This might overflow but won't throw
                Console.WriteLine($"Result of {largeValue} * {multiplier} is {result}");
            }
        }
    }
}

Step 3: Demonstrating the unchecked Keyword

In this part, you perform an addition that will cause an overflow without raising an exception. The unchecked keyword is used to disable overflow checking.

Step 4: Demonstrating the checked Keyword for Addition

Here, you intentionally cause an integer overflow within a checked block. Since overflow is detected, an OverflowException is thrown, which is caught and handled in the catch block.

Step 5: Demonstrating the checked Keyword for Subtraction

Another demonstration is provided, this time subtracting 1 from int.MinValue which results in an underflow. Similar to the addition example, an OverflowException is thrown and caught.

Step 6: Using checked and unchecked in a Larger Scope

This part illustrates the use of checked and unchecked in a larger code block, showing the behavior for both multiplication scenarios.

Step 7: Run the Program

After writing the code, run the program in your development environment to see the results.

Output

You should see the following output:

Demonstrating unchecked keyword...
Result of 2147483647 + 1 is -2147483648

Demonstrating checked keyword for addition...
Exception caught: Arithmetic operation resulted in an overflow.

Demonstrating checked keyword for subtraction...
Exception caught: Arithmetic operation resulted in an overflow.

Using checked and unchecked in a larger scope...
Exception caught: Arithmetic operation resulted in an overflow.
Result of 2100000000 * 10 is 1728000000

Conclusion

By using checked and unchecked, you can control how your C# application handles arithmetic overflows and underflows. This can be particularly useful in scenarios where precise control over numerical operations is critical. It's a good practice to use checked blocks in contexts where overflow could lead to erroneous or unpredictable behavior.