c# pdf viewer itextsharp : How to reorder pages in pdf software application cloud windows html asp.net class Windows%20Powershell%20in%20Action%202nd%20Edition60-part1517

570
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
features. If you have a programming background, you’re probably more familiar with 
terminating errors when they’re called by their more conventional name—exceptions. 
So call them what you will; we’re going to delve into catching these terminating 
errors. We’ll look at ways to trap or catch these errors and take some action as a con-
sequence. In some cases, these may be remedial actions (such as trying to fix the prob-
lem)  or  simply  recording  that  the  errors  occurred.  PowerShell  provides  two 
statements for dealing with terminating errors: the 
trap
statement, which is some-
what similar to the 
on error
statement in Visual Basic or 
VBS
cript, and the 
try/ 
catch
statement, modeled after the 
try/catch
statement in 
C
#.
14.2.1
The trap statement
The only way for exceptions to be caught in PowerShell v1 was by using the 
trap
state-
ment. This feature is also present in PowerShell v2 and has some unique characteristics 
that we’ll cover in this section. The 
trap
statement syntax is shown in figure 14.5.
The 
trap
statement can appear anywhere in a block of code. This means that it 
may be specified after a statement that generates an error and still handle that error. 
When an exception (terminating error) occurs that isn’t otherwise handled, control 
will be transferred to the body of the 
trap
statement and the statements in the body 
are then executed. 
You can optionally specify the type of exception to catch, such as division by zero. 
If no exception is specified, then it will trap all exceptions. Here’s an example:
PS (1) > trap { "Got it!"  } 1/$null 
Got it!
Attempted to divide by zero.
At line:1 char:30 
+ trap { "Got it!" ; break } 1/$ <<<< zero
In this example, the statement
1/$null
was executed. 
$null
is treated like zero in integer expressions, causing a division-by-
zero exception to occur. When this happens, control transfers to the statement list in 
the body of the 
trap
statement. In this case, it just writes “Got it!” which you see in
trap    [<exceptionType>]
{
<statementList>
}
trap keyword
.NET type of exception to trap;
optional and may be omitted
Body of trap
statement
Figure 14.5 The syntax of the 
trap
statement. The body of the statement 
will be executed when an exception with matching type is caught. If no ex-
ception type is specified, all exceptions will be caught.
How to reorder pages in pdf - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
how to reorder pages in pdf file; reorder pages in pdf preview
How to reorder pages in pdf - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
how to move pages in pdf files; move pages in a pdf
D
EALING
WITH
ERRORS
THAT
TERMINATE
EXECUTION
571
the output. You also see that the error message is still displayed, even though you 
trapped this exception. This is a significant point. What happens after a 
trap
handler 
execution has completed depends on how the block finishes. If the body of the 
trap 
handler block finishes normally, an error object will be written to the error stream, 
and, depending on the setting of 
$ErrorActionPreference
, either the exception 
will be rethrown or execution will continue at the statement after the statement that 
caused the exception. This is what you saw in the previous example. To make this 
point clearer, let’s add another statement after the one that caused the error:
PS (2) > trap { "Got it!" } 1/$zero; "LAST" 
Got it!
Attempted to divide by zero.
At line:1 char:22 
+ trap { "Got it!" } 1/$ <<<< zero; "LAST" 
LAST
You see the error message—but following it, you see output from the last statement.
The interpreter’s behavior after you leave the 
trap
handler can be controlled by 
the 
break
and 
continue
keywords. (See chapter 6 for other uses of these keywords.) 
Let’s look at 
break
first. Here’s the example again, but this time you’ll terminate the 
trap
block with 
break
:
PS (3) > trap { "Got it!"; break  } 1/$zero; "LAST" 
Got it!
Attempted to divide by zero.
At line:1 char:30 
+ trap { "Got it!"; break  } 1/$ <<<< zero; "LAST"
You see the error record, but you don’t see the output 
"LAST"
because after the 
trap 
block exited, the error was rethrown as a terminating error instead of resuming execu-
tion. This flow of control is shown in figure 14.6.
The other modification to the 
trap
flow control is to use the 
continue
statement:
PS (4) > trap { "Got it!"; continue  } 1/$zero; "LAST" 
Got it!
LAST
This time, you see the output from the 
trap
block and from the 
"LAST"
statement, but 
no error record. Exiting a trap block is somewhat equivalent to the error action preference
trap
{
"Got it!"; break
1/$zero 
"LAST"
Division by zero
causes exception, 
transferring control to 
trap statement
When trap body
completes by calling 
break, execution
resumes, skipping 
"
LAST
"
Figure 14.6 The flow of control when 
break
is used in a 
trap
statement. When the division-
by-zero exception occurs, control jumps to the 
trap
block and then breaks out of the script.
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview. Reorder TIFF Pages in C#.NET Application.
change page order pdf reader; rearrange pdf pages in reader
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Sort and Reorder PowerPoint Slides Range with VB amount of robust PPT slides/pages editing methods powerful & profession imaging controls, PDF document, image
change page order in pdf reader; how to move pages around in a pdf document
572
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
SilentlyContinue
. This works in a similar manner to the 
VBS
cript 
On  Error 
Resume Next
statement. Figure 14.7 shows the control flow when 
continue
is used.
There’s one other feature available in the 
trap
block itself. The exception that 
was trapped is available in the 
trap
block in the 
$_
variable. Here’s the example, but 
with the output of the 
trap
statement showing the value in 
$_
as a string:
PS (5) > trap { "Got it: $_"; continue  } 1/$zero; 
Got it: Attempted to divide by zero.
In this case, the output is the 
ToString()
of the exception. But 
$_
isn’t an exception; 
it’s an error record, so the 
trap
handler has full access to all the information in the 
error handler. Let’s verify the type of this object:
PS (6) > trap { "Got it: " + $_.gettype(); continue  } 1/$zero; 
Got it: System.Management.Automation.ErrorRecord
In the 
trap
block in this example, you’re displaying the type of the value in 
$_
. How 
all this works is shown in figure 14.8.
There are some paths through the figure that we haven’t talked about yet, so let’s 
work through a few more examples. We said earlier that control transfers to the next 
statement after the one that caused the exception. Actually it’s a bit more complicated 
than that. It transfers to the next statement in the same scope as the 
trap
statement. 
This flow of control is illustrated in figure 14.9.
And now an example. You’ll use scriptblocks to create the two scopes. The code 
looks like this:
&{
trap {"TRAP"}
&{
"one"
"two"
1/$null
"three"
"four"
}
"OUTERBLOCK" 
}
trap
{
"Got it!"; continue
1/$zero 
"LAST"
Division by zero
causes exception, 
transferring control to 
trap statement
When trap body completes
by calling continue,
execution resumes at 
"LAST" statement 
Figure 14.7 The flow of control when 
continue
is used in a 
trap
statement instead 
of 
break
. When the division-by-zero exception occurs, control jumps to the 
trap
block and then resumes at the 
"LAST"
statement before exiting the script.
Read PDF in Web Image Viewer| Online Tutorials
from PDF documents; Extract images from PDF documents; Add, reorder pages in PDF files; Save and print PDF as you wish; More PDF Reading
reorder pages pdf; how to rearrange pages in a pdf document
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
Users can use it to reorder TIFF pages in ''' &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
how to move pages around in pdf file; reverse page order pdf online
D
EALING
WITH
ERRORS
THAT
TERMINATE
EXECUTION
573
Hit break
statement?
Statement generates
terminating exception
Write error, then
rethrow exception
Is there a trap
in scope?
Qualified by
matching exception?
Is there an
unqualified trap?
Execute trap
body
Yes
Yes
Yes
Yes
No
No
No
No
Hit continue
statement?
Trap block
exits, error is 
written, and
execution 
continues at next
statement
Don’t write error;
continue with next 
statement
Yes
No
Execution for current block
is terminated, and
exception propagates up
until it’s trapped or caught 
or top level is reached
Figure 14.8 A flow chart illustrating the complete 
error-handling logic used by the 
trap
statement 
trap
{
<trap body>
}
Statement 1
Statement 2
Statement 3 error
Statement 4
Statement 5
Statement 6
Statement 3 generates
terminating error, 
causing control to pass
to trap statement
When trap body
completes, execution
resumes at statement 4 
Figure 14.9  The flow of control when a 
trap
statement is used. If there’s 
trap
statement in scope, control transfers to the body of the 
trap
statement where the error is processed.
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
page, it is also featured with the functions to merge PDF files using C# .NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split
how to reorder pages in a pdf document; pdf reverse page order online
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
just following attached links. C# PDF: Add, Delete, Reorder PDF Pages Using C#.NET, C# PDF: Merge or Split PDF Files Using C#.NET.
how to rearrange pages in pdf document; how to reorder pdf pages in
574
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
The 
trap
statement in the outer block writes out the string “TRAP” so you’ll know it 
was executed:
PS (7) > & { 
>> trap {"TRAP"} 
>> &{
Now create an inner scope that will emit a number of strings:
>> "one" 
>> "two" 
>> 1/$null
Part of the way through, throw an exception:
>> "three" 
>> "four" 
>> } 
>> "OUTERBLOCK"
At the end of the output block, write out the string “OUTERBLOCK” so you’ll 
know where you are:
>> } 
>> 
one 
two 
TRAP 
Attempted to divide by zero. 
At line:6 char:3 
+ 1/$ <<<< null 
OUTERBLOCK
Look at the output that  was produced.  You  can see the first  couple of numbers 
printed and then the exception, but look where execution resumed—at the first state-
ment outside the block. This pattern allows you to skip entire sections of code instead 
of a single line, as shown in figure 14.10.
& { 
trap {"TRAP"}
& { 
"one"
"two"
1/$null
"three"
"four"
}
"OUTERBLOCK"
}
Executing 1/$null
generates terminating
error, causing control to
pass to trap statement
When trap body
completes, execution
resumes at
"OUTERBLOCK " statement
Figure 14.10 The flow of control when a 
trap
statement is used with nest-
ed blocks. When the error occurs, control transfers to the 
trap
body. When 
the 
trap
body completes, execution resumes at the first statement after the 
nested scriptblock.
.NET Multipage TIFF SDK| Process Multipage TIFF Files
SDK, developers are easily to access, extract, swap, reorder, insert, mark up and delete pages in any multi upload to SharePoint and save to PDF documents.
change pdf page order; rearrange pdf pages reader
C# Word: How to Create Word Document Viewer in C#.NET Imaging
in C#.NET; Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; Rich options to add
how to change page order in pdf document; how to rearrange pages in a pdf file
D
EALING
WITH
ERRORS
THAT
TERMINATE
EXECUTION
575
It essentially mimics the way the 
try/catch
statement found in other languages such 
as 
C
# works and was the only way to accomplish this in version 1. In fact, the 
try/ 
catch
(or 
try/catch/finally
) pattern is so common that it was added to Power-
Shell in v2. We’ll look at how this statement can be used to simplify your scripts in 
the next section.
14.2.2
The try/catch/finally statement
The 
trap
statement, while powerful and flexible, ended up being hard to use for a lot 
of the traditional script/programming error-handling patterns. To address this, v2 
introduced the more familiar 
try/catch/finally
statement found in other lan-
guages. As is the case with all of the other PowerShell flow-control statements, this 
statement adopts the syntax from 
C
#. This syntax is shown in figure 14.11.
The figure shows that there are three parts to this statement: the 
try
block, the 
catch
block, and the 
finally
block. The 
try
block is always required along with at 
least one of the 
catch
or 
finally
clauses. If an error occurs in the code in the 
try 
block resulting in an exception, PowerShell checks to see if there is a 
catch
block 
specified. If there is a 
catch
block, then it checks to see if specific exception types are 
to be caught. If there is and at least one of the specified types matches, then the 
catch
block is executed. If not, then the search continues looking for another 
catch 
block that might match.
NOTE
This is one place where the PowerShell 
try/catch
statement 
has some advantages over its 
C
# cousin. In 
C
#, only one exception can 
be specified per catch clause so it’s more complicated to take the same 
action for multiple exceptions that don’t have a common base class.
If there’s a 
catch
block with no exception types specified, this clause will be executed 
(which tends to be the most common case). And if there’s a 
finally
block, the code
try
{
statement1
statement2
catch [Exception Type Name List...]
{
statement3
statement4
finally
{
statement5
statement6
}
try keyword
Statements that may result in
exception being thrown
catch keyword
allowing zero, one, 
or more exception
types to catch 
finally keyword;
optional block
Statements executed if
exception of matching type
is thrown; catch block can
be omitted if there is a 
finally block
Statements that will always be
executed (optional); catch 
and finally can be used
together but at least one must
be present
Figure 14.11 The syntax of the 
try/catch/finally
statement. This statement allows 
exceptions to be processed in a structured way.
576
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
in the 
finally
block runs. (Actually the 
finally
block always runs whether there 
was an exception or not.) Here’s an example using a 
catch
statement with no excep-
tion type specified:
PS (1) > try 
>> { 
>>     1 
>>     2 
>>     3/$null 
>>     4 
>>     5 
>> } 
>> catch 
>> { 
>>     "ERROR: $_" 
>> } 
>> finally 
>> { 
>>     "ALL DONE" 
>> } 
>> 
ERROR: Attempted to divide by zero. 
ALL DONE 
PS (2) >
In this example, the third statement in the 
try
block causes a terminating error. This 
error is caught and control transfers to the 
catch
block. Then, when the 
catch
block 
is complete, the 
finally
block is executed. This flow of control is shown in figure 14.12.
The complete processing logic for the 
try/catch/finally
statement is shown in 
the flowchart in figure 14.13.
Which should you use in your scripts? In general, the flow of control with 
try/ 
catch/finally
is almost always easier to understand than the 
trap
statement
try
{
1
2
3/$null
4
5
}
catch
{
"ERROR: $_"
finally 
{
"ALL DONE"
}
Executing 3/$null 
generates terminating error,
causing control to pass to
the catch block; "ERROR: 
Attempted to divide
by zero" emitted
When catch block completes,
execution transfers to finally 
block; "ALL DONE" emitted
Figure 14.12 The flow of control in a 
try/catch/finally
statement. When an 
exception occurs, control transfers to the 
catch
block and then the 
finally
block.
D
EALING
WITH
ERRORS
THAT
TERMINATE
EXECUTION
577
except in some very simple cases. For example, in a function or script, you may want 
to have a general “catch all” exception that generates an error and then exits the func-
tion or script. You can do so simply by putting a 
trap
statement at the top of the 
script rather than wrapping the body of the script in a 
try/catch
. There are also 
some exception handling patterns that can be expressed with 
trap
that are hard to 
handle with 
try/catch
. That said, if you encounter something like this, think hard 
about what you’re doing. The 
trap
statement is like the infamous 
goto
statement: 
you can express any flow of control, but patterns that can’t be expressed with a struc-
ture statement tend to be hard to understand, debug, and maintain.
finally
block?
Execute try block
Execute finally
block
Exception?
Catch with
matching 
exception
Execute catch
block
Catch all
Execute catch
block
Yes
Yes
Yes
Yes
No
No
No
No
Figure 14.13 The complete logical flow in 
the 
try/catch/finally
statement
578
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
Using try/catch in expressions
An interesting application of the 
try
/
catch
statement when used in combination 
with PowerShell’s expression-oriented syntax is that it makes it fairly easy to write 
functions that provide default values if an expression throws an exception. Let’s look 
at using 
try
/
catch
in a custom 
div
function. We want a function that never throws 
an exception even when dividing by zero. The function might look like this:
function div ([int] $x, [int] $y) {try { $x/$y } catch {[int]::MaxValue}}
Give it a try
PS (2) > div 1 0 
2147483647
and you get the maximum integer value instead of the error you normally get when 
you divide by zero:
PS (3) > 1/0
Attempted to divide by zero. 
At line:1 char:3 
+ 1/ <<<< 0
+ CategoryInfo          : NotSpecified: (:) [], ParentConta
insErrorRecordException
+ FullyQualifiedErrorId : RuntimeException
We’ll take a look at another application of this technique later in section 14.3.3 when 
we talk about handling nonexistent property errors.
Clearly exceptions are a powerful error-handling mechanism. With this mecha-
nism, errors are never missed because you forgot to check for a return code. In fact, 
you have to do the opposite and take action to suppress them instead. Having mas-
tered catching other people’s exceptions, let’s look at how you can leverage this fea-
ture in your own scripts with the 
throw
statement.
14.2.3
The throw statement
To complete the exception handling topic, you need a way to generate terminating 
errors or exceptions. You can accomplish this by using the 
throw
statement.
NOTE
In the original design, 
throw
was supposed to be a cmdlet rather 
than a keyword in the language. But having a cmdlet throw the excep-
tion meant that the thrown exception was subject to the cmdlet’s error 
action policy, and the whole point of 
throw
was to bypass this policy 
and always generate an exception. It wasn’t so much a case of the tail 
wagging the dog as it was staple-gunning the poor beast to the floor. And 
so, learning from past mistakes, Microsoft made it into a keyword.
The syntax of the 
throw
statement is shown in figure 14.14.
D
EALING
WITH
ERRORS
THAT
TERMINATE
EXECUTION
579
The simplest example is to throw nothing:
PS (8) > throw 
ScriptHalted 
At line:1 char:5 
+ throw <<<<
This approach is convenient for casual scripting. You don’t need to create an error 
object or exception object—the 
throw
statement takes care of all of this. Unfortu-
nately, the message you get isn’t very informative. If you want to include a meaningful 
message, you can easily provide your own:
PS (9) > throw "My Message!"
My Message!
At line:1 char:6 
+ throw  <<<< "My Message!"
You see the message in the output. It’s also possible to use 
throw
to throw 
Error-
Record
objects or .
NET
exceptions if you want to use more detailed error handling. 
Instead of passing a string, you pass these objects.
Now let’s revisit the multiscope 
catch
and use 
throw
this time instead of divid-
ing by 
$null
:
PS (10) > &{ 
>> trap {"$_" ; continue} 
>> &{ 
>> "one" 
>> "two" 
>> throw "CATCH" 
>> "three" 
>> } 
>> "ALL DONE" 
>> } 
>> 
one 
two 
CATCH 
ALL DONE
The pattern is the same as in the previous case, except that now you throw a specific 
message that appears in the output. This is followed by the output from the next 
statement in the outer scope.
throw  [<expression>] 
throw keyword
Optional expression that
produces value to throw
Figure 14.14 The syntax of the 
throw
statement
Documents you may be interested
Documents you may be interested