Exception Statements in C#

This article has been excerpted from book "The Complete Visual C# Programmer's Guide" from the Authors of C# Corner.

C# supports structured exception handling similar to that seen in C++. In structured exception handling, you write code surrounded by blocks. If an exception occurs, the block throws the execution control to a predefined handled code. The try, catch, finally statements define these blocks. In other words, if an application handles exceptions that occur during the execution of a block of application code, the code must be placed within a try statement. Application code within a try statement is a try block. Application code that handles exceptions thrown by a try block is placed within a catch statement and is called a catch block. In a try block, you define the code you want to execute and protect from any possible errors. The catch block defines the handlers for the exception. The finally block is used to free resources allocated in the try block.

The try statement provides a mechanism to capture exceptions in a block of code and a mechanism to execute blocks of code both under normal circumstances and when an exception occurs.

You can define a try statement in a few different forms:

try-catch
try-finally
try-catch-finally

Let's discuss each one of them below.

Try-Catch

In try-catch, a try block is followed by one or more catch blocks. You basically surround the block of code where you expect an error to occur with the try statement followed by one or more catch blocks to handle one or more types of exceptions. Let's look at the example in Listing 7.1 to understand it better:

Listing 7.1: Exception1.cs, Try-Catch Example

using System;
using System.Text;

public class LearnAboutTryCatch1
{
public static void GenerateException(Int32 arg1, Int32 arg2)
{
Int32 result1;
result1 = 0;

try
{
//BLOCK OF CODE WHERE ERRORS ARE EXPECTED
//division
result1 = arg1 / arg2;
Console.WriteLine(result1);
}

catch (System.DivideByZeroException e)
{
//HANDLE THE ERROR
//StackTrace gives us the location of error as string
Console.WriteLine(String.Concat(e.Message, e.StackTrace));
//e.Message: gives the error message in this case,
//Attempted to divide by zero.
//e.Stacktrace: gives the location of the error in text
//form. In this case at
//LearnAboutTryCatch1.GenerateDivideByZeroError(Int32
// Numerator,Int32 Denominator)
//in this case the output would be
//Attempted to divide by zero. at
//LearnAboutTryCatch1.GenerateDivideByZeroError(
// Int32 Numerator,Int32 Denominator)
}
}

public static void Main()
{
GenerateException(6, 0);
Console.ReadLine();
}
}

Output of above listing:

fig7.1.gif

First we create the class LearnAboutTryCatch1, which has the method GenerateException that divides two numbers. The block of code where we would expect errors in this case, the division operation is surrounded by the try clause. The try clause is followed by a catch statement, which has an argument of type System.DivideByZeroException to catch divide-by-zero errors. If you divide a number by zero, this causes a divide-by-zero exception.

You have to handle all of the exceptions inside the catch clause. In this example, the block of code inside the catch clause writes a message to console. Note that we have concatenated the Message property and the StackTrace property of the exception to generate the message. The Message property gives the actual error message, and the StackTrace gives the location of the actual error. Finally in the Main() method, we call the function by passing 6 and 0 to generate a divide-by-zero error. Now, in Listing 7.2, we will modify the code above to illustrate how to use multiple catch statements:

Listing 7.2: Exception2.cs, Second Exception Example

using System;
using System.Text;

public class LearnAboutTryCatch2
{
public static void GenerateException(Int32 arg1, Int32 arg2)
{
Int32 result1 = 0;
Int32 result2 = 0;

try
{
//BLOCK OF CODE WHERE ERRORS ARE EXPECTED
//division
result1 = arg1 / arg2;
//multiplication
result2 = arg1 * arg2;
Console.WriteLine(result1);
Console.WriteLine(result2);
}

catch (System.DivideByZeroException e)
{
//HANDLE THE ERROR
//StackTrace gives us the location of error as
// string
Console.WriteLine(String.Concat(e.Message, e.StackTrace));

//e.Message: gives the error message, in this
// case, Attempted to divide by zero.
//e.Stacktrace: gives the location of the error
//in text form. In this case at
// LearnAboutTryCatch1.GenerateDivideByZeroError(Int32 Numerator,Int32 Denominator)
//in this case the output would be
//Attempted to divide by zero. at
//LearnAboutTryCatch1.GenerateDivideByZeroError(
// Int32 Numerator,Int32 Denominator)
}

catch (System.OverflowException e)
{
//HANDLE THE ERROR
//StackTrace gives us the location of error as
// string
Console.WriteLine(String.Concat(e.Message, e.StackTrace));

//e.Message: gives the error message in this case,
//e.Stacktrace: gives the location of the
// error in text form.
}
}

public static void Main()
{
GenerateException(6, 0);
GenerateException(999999999, 999999999);
Console.ReadLine();
}
}

Figure 7.2 shows the output of Listing 7.2 in the console. Note that it shows the divide by zero error and its location in the code.

fig7.2.gif

Figure 7.1: The Output of Listing 7.2

We have added a multiplication operation inside the GenerateException function, and we have also added one more catch clause to handle System.OverflowException, which could result from multiplying two big numbers. For example, if the resulting value of the multiplication is bigger than what an Int32 type can hold, we would expect to get an overflow exception so we have to add one catch block for each exception. Hence, this example, Listing 7.2, demonstrates how to handle more than one type of exception.

Assume that we have passed 999999999 as arg1 and 999999999 as arg2 to the GenerateException method. Note that result2 is Int32 type, and when we multiply 999999999 and 999999999, we get a stack overflow error.

Compile the code as usual with the following command:

csc LearnAboutTryCatch2.cs.

Once you run LearnAboutTryCatch2.exe, you would expect that both the divide-by-zero and the overflow exceptions would be thrown. However, you would be surprised to know that only the divide-by-zero exception is raised and not the overflow exception because result1=arg1/arg2; code comes first.

What if you want to change this behavior? This leads us to the next important concept, checked and unchecked statements in C#.

The different ways of controlling overflow behavior are listed below:

Set the compiler option to checked+ or checked–
Add the checked statement and unchecked statement to your code Compiler options apply to the application level whereas checked and unchecked statements can apply to specific blocks of code. Checked and unchecked statements always override the compiler options, so if you have compiled with the checked+ option and have a block of code surrounded by an unchecked statement, the overflow exception will not be raised for any overflow conditions within the unchecked block. Similarly, if you have compiled with the checked– option and have a block of code surrounded by the checked statement, the overflow exception would be raised for any overflow conditions within the checked block of code. Listing 7.3 shows what the code looks like after adding the checked statement.

Listing 7.3: Exception3.cs, Checked-Unchecked Example

using System;
using System.Text;

public class LearnAboutTryCatch1
{
public static void GenerateException(Int32 arg1, Int32 arg2)
{
Int32 result1 = 0;
Int32 result2 = 0;

try
{
//BLOCK OF CODE WHERE ERRORS ARE EXPECTED
//division
result1 = arg1 / arg2;

//multiplication
checked
{
result2 = arg1 * arg2;
}

Console.WriteLine(result1);
Console.WriteLine(result2);
}

catch (System.DivideByZeroException e)
{
//HANDLE THE ERROR
//StackTrace gives us the location of error
// as string
//e.Message: gives the error message in this
Console.WriteLine(String.Concat(e.Message, e.StackTrace));

// case, Attempted to divide by zero.
//e.Stacktrace: gives the location of the error
// in text form. In this case at
// LearnAboutTryCatch1.GenerateDivideByZeroError(
// Int32 Numerator,Int32 Denominator)
//in this case the output would be
//Attempted to divide by zero. at
// LearnAboutTryCatch1.GenerateDivideByZeroError(
// Int32 Numerator,Int32 Denominator)
}

catch (System.OverflowException e)
{
//HANDLE THE ERROR
//StackTrace gives us the location of error as
//string.
//e.Message: gives the error message in this
// case,
//e.Stacktrace: gives the location of the error
// in text form.
Console.WriteLine(String.Concat(e.Message, e.StackTrace));
}
}

public static void Main()
{
GenerateException(6, 0);
GenerateException(999999999, 999999999);
Console.ReadLine();
}
}

Figure 7.2 illustrates the output of the overflow exception to the console resulting from using the checked keyword in Listing 7.3.

fig7.3.gif

Figure 7.2: Output of Listing 7.3

The code in Listing 7.3 would raise both exceptions: the divide-by-zero exception and the overflow exception. We leave it to you as an exercise to play with different combinations of compiler options, as well as checked and unchecked statements.

Now, let's say we want to capture all other exceptions other than the specific exceptions described here (DivideByZeroException and OverflowException). To do that we have to add another catch statement with the argument of type System.Exception. By adding the System.Exception, the code now will look like Listing 7.4. Pay specific attention to the place where we insert the catch statement.

Listing 7.4: Exception4.cs, General Exception Example

using System;
using System.Text;

public class LearnAboutTryCatch1
{
public static void GenerateException(Int32 arg1, Int32 arg2)
{
Int32 result1 = 0;
Int32 result2 = 0;

try
{
//BLOCK OF CODE WHERE ERRORS ARE EXPECTED
//division
result1 = arg1 / arg2;
//multiplication

checked
{
result2 = arg1 * arg2;
}
Console.WriteLine(result1);
Console.WriteLine(result2);
}

catch (System.DivideByZeroException e)
{
//HANDLE THE ERROR
//StackTrace gives us the location of error as string
//e.Message: gives the error message, in this
// case, Attempted to divide by zero.
Console.WriteLine(String.Concat(e.Message, e.StackTrace));

//e.Stacktrace: gives the location of the error in text form. In
// this case at LearnAboutTryCatch1.GenerateDivideByZeroError(
// Int32 Numerator,Int32 Denominator)
//in this case the output would be
//Attempted to divide by zero. at
// LearnAboutTryCatch1.GenerateDivideByZeroError(
// Int32 Numerator,Int32 Denominator)
}

catch (System.OverflowException e)
{
//HANDLE THE ERROR
//stackTrace gives us the location of error as string
//e.Message: gives the error message in this case,
//e.Stacktrace: gives the location of the error in text
// form.
Console.WriteLine(String.Concat(e.Message, e.StackTrace));
}
}

public static void Main()
{
GenerateException(6, 0);
GenerateException(999999999, 999999999);
Console.ReadLine();
}
}
Output of above listing:

fig7.4.gif

The compiler would not let you compile the code in Listing 7.4. Instead, it would give you the following error message: "A previous catch clause already catches all exceptions of this or a super type ('System.Exception')." The lesson to learn is you have to first catch specific exceptions and then catch the general exception (System.Exception). We leave it as an exercise for you to change the code above to fix the order of catching exceptions.

As shown in Listing 7.5, there are two ways to catch a general System.Exception. In the first case you would capture the exception and get all the information about it from the Exception parameter. However, in the second code block you would not have access to that information.

Listing 7.5: Try-Catch Syntax

try
{
}

catch(Exception e)
{
}

and

try
{
}

catch
{
}

Conclusion

Hope this article would have helped you in understanding Exception Statements in C#. See other articles on the website on .NET and C#.

The Complete Visual C# Programmer's Guide covers most of the major components that make up C# and the .net environment. The book is geared toward the intermediate programmer, but contains enough material to satisfy the advanced developer.