Home > Articles > Certification > Microsoft Certification

MCAD Exam 70-316: Handling Visual C# .NET Exceptions

  • Print
  • + Share This
Learn about exceptions and how to handle these situations with the help of try, catch, and blocks. You will also see how to handle unhandled exceptions at the level of application domain.
This chapter is from the book

Terms you'll need to understand:

  • Exception

  • try block

  • catch block

  • finally block

  • throw statement

  • Validation

  • Validating event

  • ErrorProvider component

Techniques you'll need to master:

  • Know the default application behavior that occurs when an unhandled exception is encountered.

  • Understand the use of try, catch, and finally code blocks.

  • Understand the different techniques of user input validation.

This chapter discusses exceptions, which appear as an outcome of unexpected problems during the normal execution of a program. The chapter focuses on how to handle such exceptional situations with the help of try, catch, and finally blocks. You will also learn how to handle unhandled exceptions at the level of application domain.

We also discuss the different user input validation techniques and cover how to use the ErrorProvider component to display error messages.

Understanding Exceptions

When an application encounters an unexpected situation such as a missing file or input parameter, or a logical error such as performing a division by zero, the application generates exceptions. By default, when an exception is generated, the application terminates and generates an error display such as the one shown in Figure 3.1.

Figure 3.1Figure 3.1   This is an example error message, caused when an application commits a logical error, such as attempting to divide by zero.

Unhandled exceptions in an application can result in unexpected termination and lost data, and potentially even can create security holes if input values are not properly restricted. Visual C# .NET helps you fire and handle exceptions with the help of try, catch, finally, and throw statements. The Framework Class Library (FCL) includes a large set of exception classes for dealing with various unforeseen conditions in the normal execution environment.

The .NET Framework provides two exception classes that derive from the common Exception class:

  • ApplicationException—Exceptions thrown by the application

  • SystemException—Exceptions thrown by the CLR

Both of these child exception classes enjoy the same properties and are differentiated only in the source of the exception they represent. Table 3.1 details some of the important properties of the Exception class, inherited by the exception classes.

Table 3.1 Important Properties of the Exception Class




The URL for a help file associated with the current exception.


An exception associated with the current exception. This is helpful when a series of exceptions are involved. Each new exception can preserve the information about the previous exception by storing it in this property.


A message explaining the error and possibly offering ways to resolve it.


The name of the application that caused the error.


Retrieves the current stack trace information. You can use this information to locate where an error has occurred. If debugging information is available, the stack trace includes the source file and program line number.


The method that threw the exception.

  • + Share This
  • 🔖 Save To Your Account