Learn more

Become a developer with our complete learning paths

Learn more

Become a developer with our complete learning paths

Using Try and Catch in .NET 7.0 to handle Common Exceptions

C# is a popular programming language used for building robust applications. One of the key features of C# is its error-handling mechanism. C# provides a powerful error-handling mechanism using try-and-catch blocks. In this article, we will explore the try-catch-finally block in C# .NET 7, and how to handle three common exceptions using Try and Catch in .NET 7.0: FormatException, OverflowException, and ArgumentNullException.

If you want to skyrocket your C# career, check out our powerful ASP.NET FULL-STACK WEB DEVELOPMENT COURSE, which also covers test-driven development and C# software architecture.

Try-Catch-Finally Block

The try-catch-finally block is a fundamental feature of C# error handling. It provides a structured mechanism for handling errors in C# programs. The try block contains the code that might throw an exception. The catch block handles the exception, and the finally block contains code that is executed regardless of whether an exception is thrown.

The general syntax of the try-catch-finally block is:

try
{
    // Code that might throw an exception
}
catch (ExceptionType1 ex1)
{
    // Handle ExceptionType1
}
catch (ExceptionType2 ex2)
{
    // Handle ExceptionType2
}
finally
{
    // Code that is executed regardless of whether an exception is thrown
}

The try block contains the code that might throw an exception. If an exception is thrown, the catch block catches the exception and handles it. The catch block can catch specific types of exceptions using the exception type as a parameter. If the exception is not caught by any catch block, it is thrown to the caller. The finally block contains code that is executed regardless of whether an exception is thrown or not.

Handling FormatException

FormatException is an exception that is thrown when a value cannot be converted to the appropriate format. For example, if you try to convert a string that contains letters to an integer, a FormatException will be thrown. To handle FormatException using try-catch block, you can catch it in the catch block and handle it gracefully.

try
{
    int num = int.Parse("abc"); // This will throw a FormatException
}
catch (FormatException ex)
{
    Console.WriteLine("Invalid format: {0}", ex.Message);
}
finally
{
    Console.WriteLine("Finally block is executed");
}

In the above code snippet, we are trying to convert a string “abc” to an integer using the int.Parse method. This will throw a FormatException because the string cannot be converted to an integer. We catch the FormatException in the catch block and print a message indicating that the format is invalid. The finally block is executed regardless of whether an exception is thrown or not.

Handling OverflowException

OverflowException is an exception that is thrown when an arithmetic operation results in an overflow. For example, if you try to add two numbers that are too large to be represented by the data type, an OverflowException will be thrown. To handle OverflowException using try-catch block, you can catch it in the catch block and handle it gracefully.

try
{
    int num = int.MaxValue;
    int result = num + 1; // This will throw an OverflowException
}
catch (OverflowException ex)
{
    Console.WriteLine("Arithmetic overflow: {0}", ex.Message);
}
finally
{
    Console.WriteLine("Finally block is executed");
}

In the above code snippet, we are adding 1 to the maximum value of an integer using the int.MaxValue property. This will result in an overflow and throw an OverflowException. We catch the OverflowException in the catch block and print a message indicating that an arithmetic overflow has occurred. The finally block is executed regardless of whether an exception is thrown or not.

However, here, the Overflow exception is not guaranteed. Now don´t get this wrong, the int result is for sure overflowing as 1 is being added to the max value it can hold. But for C# to check for these exceptions at this point, we need to use the checked keyword. To guarantee an overflow exception is thrown when an integer overflows, you need to use the checked keyword. When you use the checked keyword, arithmetic overflow is always checked, and an OverflowException is thrown if the result of an operation is outside the bounds of the data type.

try
{
    int num = int.MaxValue;
    int result = checked(num + 1); // This will throw an OverflowException
}
catch (OverflowException ex)
{
    Console.WriteLine("Arithmetic overflow: {0}", ex.Message);
}
finally
{
    Console.WriteLine("Finally block is executed");
}

In the above code snippet, we use the checked keyword to add 1 to the num variable, which is equal to int.MaxValue. Since the result of this operation is outside the bounds of an int variable, an OverflowException is thrown. We catch the exception in the catch block and print a message indicating that an arithmetic overflow has occurred. The finally block is executed regardless of whether an exception is thrown or not.

Handling ArgumentNullException

ArgumentNullException is an exception that is thrown when a null argument is passed to a method that does not accept null arguments. For example, if you try to pass a null value to a method that expects a non-null argument, an ArgumentNullException will be thrown. To handle ArgumentNullException using try-catch block, you can catch it in the catch block and handle it gracefully.

try
{
    string str = null;
    int num = int.Parse(str); // This will throw an ArgumentNullException
}
catch (ArgumentNullException ex)
{
    Console.WriteLine("ArgumentNullException: {0}", ex.Message);
}
finally
{
    Console.WriteLine("Finally block is executed");
}

try
{
    string str = null;
    string upper = str.ToUpper(); // This will throw a NullReferenceException
}
catch (NullReferenceException ex)
{
    Console.WriteLine("NullReferenceException: {0}", ex.Message);
}
finally
{
    Console.WriteLine("Finally block is executed");
}

Learn more

Lost in coding? Discover our Learning Paths!

Learn more

Lost in coding? Discover our Learning Paths!