C# Checked and Unchecked Operators – Easy Guide with Examples

C# Checked and Unchecked Operators – Handle Overflows Like a Pro!

Ever Seen a Number Go Crazy? 😵

Imagine you’re working on an app that calculates large numbers. Everything seems fine, but suddenly, your values are completely wrong! That’s because of something called integer overflow.

When a number exceeds its limit, it wraps around like a speedometer resetting to zero! To avoid this, we use C# Checked and Unchecked Operators to control how the program reacts to such overflows.

By the end of this tutorial, you’ll know:

✅ What Checked and Unchecked Operators in C# do
✅ How to catch and prevent overflow errors
✅ When to use checked and unchecked
✅ Real-world examples with complete code

Ready? Let’s dive in! 😃

What Are Checked and Unchecked Operators in C#?

Before we jump into code, let’s understand the problem.

In C#, every numeric type has a fixed range. If a number exceeds this range, it overflows.
For example, an int can store values between -2,147,483,648 and 2,147,483,647. If you try to add 1 to the max value, it wraps around to a negative number!

Operator	Purpose
`checked`	Detects overflow and throws an exception
`unchecked`	Ignores overflow and allows incorrect results

Basic Example of Overflow Without Handling

Let’s see what happens when we don’t handle overflow:

				
					using System;

class Program
{
    static void Main()
    {
        int maxValue = int.MaxValue; // 2,147,483,647
        int result = maxValue + 1;   // Overflow happens here!

        Console.WriteLine($"Result: {result}");
    }
}

Output (Incorrect Result 😱)

				
					Result: -2147483648

What Just Happened?

int.MaxValue is 2,147,483,647.
When we add 1, it wraps around to -2,147,483,648.
No error, but the result is totally wrong!

How do we fix this? That’s where checked comes in!

1. Using Checked to Prevent Overflow

With checked, the program will detect overflow and throw an error instead of giving a wrong value.

				
					using System;

class Program
{
    static void Main()
    {
        int maxValue = int.MaxValue;

        try
        {
            int result = checked(maxValue + 1); // Overflow detection enabled
            Console.WriteLine($"Result: {result}");
        }
        catch (OverflowException ex)
        {
            Console.WriteLine($"Oops! Overflow detected: {ex.Message}");
        }
    }
}

Output (With Error Handling) 🚨

				
					Oops! Overflow detected: Arithmetic operation resulted in an overflow.

Explanation:

checked(maxValue + 1); → C# checks for overflow.
If an overflow happens, an exception is thrown.
catch (OverflowException ex) → Catches the error and prevents a crash.

This is super useful when handling sensitive calculations like bank transactions, salaries, and product prices!

2. Using Unchecked to Ignore Overflow

Sometimes, you don’t care about overflow and just want the program to continue running. That’s where unchecked helps.

				
					using System;

class Program
{
    static void Main()
    {
        int maxValue = int.MaxValue;
        int result = unchecked(maxValue + 1); // Overflow ignored

        Console.WriteLine($"Result: {result}");
    }
}

Output (No Error, But Wrong Result)

				
					Result: -2147483648

Why Use Unchecked?

✔️ When performance matters more than precision.
✔️ When you know the overflow won’t break your logic.
✔️ When you’re working with low-level bit operations.

For example, in game development, some physics calculations may use unchecked to speed up performance while accepting small inaccuracies.

Real-World Example – Secure Salary Calculation 💰

Imagine a company pays employees their salaries. If the salary calculation overflows, an employee might get paid $-50,000 instead of $50,000! 😲

Let’s prevent that using checked:

				
					using System;

class Program
{
    static void Main()
    {
        try
        {
            int baseSalary = int.MaxValue;  // Huge salary (for fun)
            int bonus = 5000;              // Bonus amount

            int totalSalary = checked(baseSalary + bonus); // Ensures safe calculation

            Console.WriteLine($"Total Salary: {totalSalary}");
        }
        catch (OverflowException)
        {
            Console.WriteLine("Oops! Salary calculation failed due to overflow.");
        }
    }
}

Output (If Overflow Occurs) 💼

				
					Oops! Salary calculation failed due to overflow.

This ensures employees don’t get wrong payments, making your app safe and reliable! 🚀

Checked vs Unchecked – Which One to Use?

Use `Checked` When…	Use `Unchecked` When…
You need precise results	You don’t care about overflow
You’re handling money, salaries, transactions	You want performance over precision
Overflow must stop the program	You’re working with low-level calculations

Wrapping It Up

Boom! 🎉 You just learned how to control overflow in C# using Checked and Unchecked Operators.

✅ Checked helps prevent incorrect calculations by detecting overflow.
✅ Unchecked allows overflow to happen without errors (use it carefully!).
✅ These operators are super useful in areas like finance, gaming, and data processing.

So, what do you think? Ever faced an unexpected number bug in your code? Try adding checked and see if it catches something weird! 🤔

Next What?

You’ve mastered Checked and Unchecked Operators in C#. But what’s next? In the next lesson, you’ll learn about Sizeof Operator – a cool way to check the size of data types in memory!

Stay curious! See you in the next lesson! 😃🚀

Complete C# Tutorial