MCAD Exam 70-316: Handling Visual C# .NET Exceptions
- Understanding Exceptions
- Handling Exceptions
- Managing Unhandled Exceptions
- Validating User Input
- Practice Questions
- Need to Know More?
This chapter is from the book
This chapter is from the book
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.
){kind=small}
Figure
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
|
Property |
Description |
|
HelpLink |
The URL for a help file associated with the current exception. |
|
InnerException |
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. |
|
Message |
A message explaining the error and possibly offering ways to resolve it. |
|
Source |
The name of the application that caused the error. |
|
StackTrace |
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. |
|
TargetSite |
The method that threw the exception. |