This page intentionally left blank 
Pdf combine - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
asp.net merge pdf files; pdf merger
Pdf combine - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
c# merge pdf; split pdf into multiple files
13
Exception Handling
A
nexception is an error that occurs at runtime. Using C#’s exception-handling 
subsystem, you can, in a structured and controlled manner, handle runtime errors. 
Aor-
handling code that previously had to be entered “by hand” into any large program. For 
example, in a computer language without exception handling, error codes must be returned 
called. This approach is both tedious and error-prone. Exception handling streamlines error-
handling by allowing your program to define a block of code, called an exceptionhandler, 
that is executed automatically when an error occurs. It is not necessary to manually check 
the success or failure of each specific operation or method call. If an error occurs, it will be 
processed by the exception handler.
Exception handling is also important because C# defines standard exceptions for common 
program errors, such as divide-by-zero or index-out-of-range. To respond to these errors, 
your pr
successful C# programmer means that you are fully capable of navigating C#’s exception-
handling subsystem.
The System.Exception Class
In C#, exceptions are represented by classes. All exception classes must be derived from the 
built-in exception class Exception, which is part of the System namespace. Thus, all exceptions 
are subclasses of Exception.
One very important subclass of Exception is SystemException. This is the exception 
class from which all exceptions generated by the C# runtime system (that is, the CLR) are 
derived.SystemException does not add anything to Exception. It simply defines the top 
of the standard exceptions hierarchy.
The .NET Framework defines several built-in exceptions that are derived from 
SystemException. For example, when a division-by-zero is attempted, a DivideByZeroException
exception is generated. As you will see later in this chapter, you can create your own 
exception classes by deriving them from Exception.
345
CHAPTER
C# PDF: C#.NET PDF Document Merging & Splitting Control SDK
PDF Merging & Splitting Application. This C#.NET PDF document merger & splitter control toolkit is designed to help .NET developers combine PDF document files
batch combine pdf; break pdf file into multiple files
Online Merge PDF files. Best free online merge PDF tool.
RasterEdge C#.NET PDF document merging toolkit (XDoc.PDF) is designed to help .NET developers combine PDF document files created by different users to one PDF
pdf combine two pages into one; batch pdf merger online
346
Part I: The C# Language
Exception-Handling Fundamentals
C# exception handling is managed via four keywords: try,catch,throw, and finally.
They form an interrelated subsystem in which the use of one implies the use of another. 
Throughout the course of this chapter, each keyword is examined in detail. However, it 
is useful at the outset to have a general understanding of the role each plays in exception 
handling. Briefly, here is how they work.
Program statements that you want to monitor for exceptions are contained within a 
try block. If an exception occurs within the try block, it is thrown. Your code can catch this 
exception using catch and handle it in some rational manner. System-generated exceptions 
are automatically thrown by the runtime system. To manually throw an exception, use the 
keyword throw. Any code that absolutely must be executed upon exiting from a try block is 
put in a finally block.
Using try and catch
At the core of exception handling are try and catch. These keywords work together, and you 
can’t have a catch without a try. Here is the general form of the try/catch exception-handling 
blocks:
try {
// block of code to monitor for errors
}
catch (ExcepType1 exOb) {
// handler for ExcepType1
}
catch (ExcepType2 exOb) {
// handler for ExcepType2
}
.
.
.
Here, ExcepType is the type of exception that has occurred. When an exception is thrown, 
it is caught by its corresponding catch clause, which then processes the exception. As the 
general form shows, more than one catch clause can be associated with a try. The type of 
the exception determines which catch is executed. That is, if the exception type specified 
by a catch matches that of the exception, then that catch is executed (and all others are 
bypassed). When an exception is caught, the exception variable exOb will receive its value.
Actually, specifying exOb is optional. If the exception handler does not need access to the 
exception object (as is often the case), there is no need to specify exOb. The exception type 
alone is sufficient. For this reason, many of the examples in this chapter will not specify exOb.
Here is an important point: If no exception is thrown, then a try block ends normally, 
and all of its catch clauses are bypassed. Execution resumes with the first statement 
following the last catch. Thus, a catch is executed only if an exception is thrown.
A Simple Exception Example
HerAs you 
know, it is an error to attempt to index an array beyond its boundaries. When this error 
occurs, the CLR throws an IndexOutOfRangeException, which is a standard exception 
VB.NET PDF: Use VB.NET Code to Merge and Split PDF Documents
APIs for Merging PDF Documents in VB.NET. Private Sub Combine(source As List(Of BaseDocument), destn As Stream) Implements PDFDocument.Combine End Sub Private
reader combine pdf pages; pdf merge documents
C# PowerPoint - Merge PowerPoint Documents in C#.NET
Combine and Merge Multiple PowerPoint Files into One Using C#. This part illustrates how to combine three PowerPoint files into a new file in C# application.
add multiple pdf files into one online; best pdf combiner
P
A
R
T
I
Chapter 13: Exception Handling 
347
P
A
R
T
I
P
A
R
T
I
defined by the .NET Framework. The following program purposely generates such an 
exception and then catches it:
// Demonstrate exception handling.
using System;
class ExcDemo1 {
static void Main() {
int[] nums = new int[4];
try {
Console.WriteLine("Before exception is generated.");
// Generate an index out-of-bounds exception.
for(int i=0; i < 10; i++) {
nums[i] = i;
Console.WriteLine("nums[{0}]: {1}", i, nums[i]);
}
Console.WriteLine("this won't be displayed");
}
catch (IndexOutOfRangeException) {
// Catch the exception.
Console.WriteLine("Index out-of-bounds!");
}
Console.WriteLine("After catch block.");
}
}
This program displays the following output:
Before exception is generated.
nums[0]: 0
nums[1]: 1
nums[2]: 2
nums[3]: 3
Index out-of-bounds!
After catch block.
Notice that nums is an int array of four elements. However, the for loop tries to index nums
from 0 to 9, which causes an IndexOutOfRangeException to occur when an index value of 
4 is tried.
Although quite short, the preceding program illustrates several key points about exception 
handling. First, the code that you want to monitor for errors is contained within a try block. 
nums
beyond its bounds inside the for loop), the exception is thrown out of the try block and 
caught by the catch.At this point, control passes to the catch block, and the try block is 
terminated. That is, catch is not called. Rather, program execution is transferred to it. Thus, 
theWriteLine( ) statement following the out-of-bounds index will never execute. After the 
catch block executes, program control continues with the statements following the catch.
Thus, it is the job of your exception handler to remedy the problem that caused the 
exception so program execution can continue normally.
C# Word - Merge Word Documents in C#.NET
Combine and Merge Multiple Word Files into One Using C#. This part illustrates how to combine three Word files into a new file in C# application.
c# combine pdf; pdf merger online
C# PDF File Split Library: Split, seperate PDF into multiple files
Split PDF document by PDF bookmark and outlines. Also able to combine generated split PDF document files with other PDF files to form a new PDF file.
merge pdf; pdf mail merge
348
Part I: The C# Language
Notice that no exception variable is specified in the catch clause. Instead, only the type 
of the exception (IndexOutOfRangeException in this case) is required. As mentioned, an 
equired. In some 
additional information about the error, but in many cases, it is sufficient to simply know 
that an exception occurred. Thus, it is not unusual for the catch variable to be absent in the 
exception handler, as is the case in the preceding program.
As explained, if no exception is thrown by a try block, no catch will be executed and 
program control resumes after the catch. To confirm this, in the preceding program, change 
thefor loop from
for(int i=0; i < 10; i++) {
to
for(int i=0; i < nums.Length; i++) {
Now, the loop does not overrun nums’ boundary. Thus, no exception is generated, and the 
catch block is not executed.
A Second Exception Example
It is important to understand that all code executed within a try block is monitored for 
exceptions. This includes exceptions that might be generated by a method called from 
within the try block. An exception thrown by a method called from within a try block 
can be caught by that try block, assuming, of course, that the method itself did not catch 
the exception.
For example, consider the following program. Main( ) establishes a try block from which 
the method GenException( ) is called. Inside GenException( ), an IndexOutOfRangeException
is generated. This exception is not caught by GenException( ). However, since GenException( ) 
was called from within a try block in Main( ), the exception is caught by the catch statement 
associated with that try.
/* An exception can be generated by one
method and caught by another. */
using System;
class ExcTest {
// Generate an exception.
public static void GenException() {
int[] nums = new int[4];
Console.WriteLine("Before exception is generated.");
// Generate an index out-of-bounds exception.
for(int i=0; i < 10; i++) {
nums[i] = i;
Console.WriteLine("nums[{0}]: {1}", i, nums[i]);
}
VB.NET TIFF: Merge and Split TIFF Documents with RasterEdge .NET
filePath As [String], docList As [String]()) TIFFDocument.Combine(filePath, docList) End to provide powerful & profession imaging controls, PDF document, tiff
add pdf together; all jpg to one pdf converter
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
Just like we need to combine PPT files, sometimes, we also want to separate a Note: If you want to see more PDF processing functions in VB.NET, please follow
adding pdf pages together; pdf mail merge plug in
P
A
R
T
I
Chapter 13: Exception Handling 
349
P
A
R
T
I
P
A
R
T
I
Console.WriteLine("this won't be displayed");
}
}
class ExcDemo2 {
static void Main() {
try {
ExcTest.GenException();
}
catch (IndexOutOfRangeException) {
// Catch the exception.
Console.WriteLine("Index out-of-bounds!");
}
Console.WriteLine("After catch block.");
}
}
This program produces the following output, which is the same as that produced by the 
first version of the program shown earlier:
Before exception is generated.
nums[0]: 0
nums[1]: 1
nums[2]: 2
nums[3]: 3
Index out-of-bounds!
After catch block.
As explained, because GenException( ) is called from within a try block, the exception that 
it generates (and does not catch) is caught by the catch in Main( ). Understand, however, 
that if GenException( ) had caught the exception, then it never would have been passed 
back to Main( ).
The Consequences of an Uncaught Exception
Catching one of the standard exceptions, as the preceding program does, has a side benefit: 
It prevents abnormal program termination. When an exception is thrown, it must be caught 
by some piece of code, somewhere. In general, if your program does not catch an exception, 
it will be caught by the runtime system. The trouble is that the runtime system will report 
an error and terminate the program. For instance, in this example, the index out-of-bounds 
exception is not caught by the program:
// Let the C# runtime system handle the error.
using System;
class NotHandled {
static void Main() {
int[] nums = new int[4];
350
Part I: The C# Language
Console.WriteLine("Before exception is generated.");
// Generate an index out-of-bounds exception.
for(int i=0; i < 10; i++) {
nums[i] = i;
Console.WriteLine("nums[{0}]: {1}", i, nums[i]);
}
}
}
When the array index error occurs, execution is halted and the following error message 
is displayed:
Unhandled Exception: System.IndexOutOfRangeException:
Index was outside the bounds of the array.
at NotHandled.Main()
say the least! This is why it is important for your program to handle exceptions itself.
As mentioned earlier, the type of the exception must match the type specified in a catch.
ogram tries to 
catch an array boundary error with a catch for a DivideByZeroException (another built-in 
exception). When the array boundary is overrun, an IndexOutOfRangeException is 
generated, but it won’t be caught by the catch. This results in abnormal program termination.
// This won't work!
using System;
class ExcTypeMismatch {
static void Main() {
int[] nums = new int[4];
try {
Console.WriteLine("Before exception is generated.");
// Generate an index out-of-bounds exception.
for(int i=0; i < 10; i++) {
nums[i] = i;
Console.WriteLine("nums[{0}]: {1}", i, nums[i]);
}
Console.WriteLine("this won't be displayed");
}
/* Can't catch an array boundary error with a
DivideByZeroException. */
catch (DivideByZeroException) {
// Catch the exception.
Console.WriteLine("Index out-of-bounds!");
}
P
A
R
T
I
Chapter 13: Exception Handling 
351
P
A
R
T
I
P
A
R
T
I
Console.WriteLine("After catch block.");
}
}
The output is shown here:
Before exception is generated.
nums[0]: 0
nums[1]: 1
nums[2]: 2
nums[3]: 3
Unhandled Exception: System.IndexOutOfRangeException:
Index was outside the bounds of the array.
at ExcTypeMismatch.Main()
As the output demonstrates, a catch for DivideByZeroException won’t catch an 
IndexOutOfRangeException.
Exceptions Let You Handle Errors Gracefully
One of the key benefits of exception handling is that it enables your program to respond 
to an error and then continue running. For example, consider the following example that 
divides the elements of one array by the elements of another. If a division-by-zero occurs, a 
DivideByZeroException is generated. In the program, this exception is handled by reporting 
the error and then continuing with execution. Thus, attempting to divide by zero does not 
cause an abrupt runtime error resulting in the termination of the program. Instead, it is 
handled gracefully, allowing program execution to continue.
// Handle error gracefully and continue.
using System;
class ExcDemo3 {
static void Main() {
int[] numer = { 4, 8, 16, 32, 64, 128 };
int[] denom = { 2, 0, 4, 4, 0, 8 };
for(int i=0; i < numer.Length; i++) {
try {
Console.WriteLine(numer[i] + " / " +
denom[i] + " is " +
numer[i]/denom[i]);
}
catch (DivideByZeroException) {
// Catch the exception.
Console.WriteLine("Can't divide by Zero!");
}
}
}
}
352
Part I: The C# Language
The output from the program is shown here:
4 / 2 is 2
Can't divide by Zero!
16 / 4 is 4
32 / 4 is 8
Can't divide by Zero!
128 / 8 is 16
removed from the system. Therefore, in the program, each pass through the loop enters the 
tryogram to 
handle repeated errors.
Using Multiple catch Clauses
You can associate more than one catch clause with a try. In fact, it is common to do so. 
However, each catch must catch a different type of exception. For example, the program 
shown here catches both array boundary and divide-by-zero errors:
// Use multiple catch clauses.
using System;
class ExcDemo4 {
static void Main() {
// Here, numer is longer than denom.
int[] numer = { 4, 8, 16, 32, 64, 128, 256, 512 };
int[] denom = { 2, 0, 4, 4, 0, 8 };
for(int i=0; i < numer.Length; i++) {
try {
Console.WriteLine(numer[i] + " / " +
denom[i] + " is " +
numer[i]/denom[i]);
}
catch (DivideByZeroException) {
Console.WriteLine("Can't divide by Zero!");
}
catch (IndexOutOfRangeException) {
Console.WriteLine("No matching element found.");
}
}
}
}
This program produces the following output:
4 / 2 is 2
Can't divide by Zero!
16 / 4 is 4
32 / 4 is 8
Can't divide by Zero!
128 / 8 is 16
P
A
R
T
I
Chapter 13: Exception Handling 
353
P
A
R
T
I
P
A
R
T
I
No matching element found.
No matching element found.
As the output confirms, each catch clause responds only to its own type of exception.
In general, catch clauses are checked in the order in which they occur in a program. 
Only the first matching clause is executed. All other catch blocks are ignored.
Catching All Exceptions
Occasionally, you might want to catch all exceptions, no matter the type. To do this, use a 
catch
catch {
// handle exceptions
}
This creates a “catch all” handler that ensures that all exceptions are caught by your 
program.
Here is an example of a “catch all” exception handler. Notice that it catches both the 
IndexOutOfRangeException and the DivideByZeroException generated by the program:
// Use the "catch all" catch.
using System;
class ExcDemo5 {
static void Main() {
// Here, numer is longer than denom.
int[] numer = { 4, 8, 16, 32, 64, 128, 256, 512 };
int[] denom = { 2, 0, 4, 4, 0, 8 };
for(int i=0; i < numer.Length; i++) {
try {
Console.WriteLine(numer[i] + " / " +
denom[i] + " is " +
numer[i]/denom[i]);
}
catch { // A "catch-all" catch.
Console.WriteLine("Some exception occurred.");
}
}
}
}
The output is shown here:
4 / 2 is 2
Some exception occurred.
16 / 4 is 4
32 / 4 is 8
Some exception occurred.
128 / 8 is 16
Some exception occurred.
Some exception occurred.
Documents you may be interested
Documents you may be interested