c# pdf viewer itextsharp : Change page order in pdf file software control project winforms web page wpf UWP Windows%20Powershell%20in%20Action%202nd%20Edition59-part1515

560
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
properties in the record followed by the invocation information for the faulting com-
mand. Then it loops, tracing through any nested exceptions 
d
, showing each one 
c
proceeded by a separator 
B
line showing the nesting depth of the displayed exception.
There’s a lot of information in these objects that can help you figure out where 
and why an error occurred. The trick is to make sure that you have the right error 
objects available at the right time. It simply isn’t possible to record every error that 
occurs—it’d take up too much space and be impossible to manage. If you limit the 
set of error objects that are preserved, you want to make sure that you keep those you 
care  about.  Obviously,  having  the  wrong  error  objects  doesn’t  help.  Sometimes 
you’re interested only in certain types of errors or only in errors from specific parts of 
a script. To address these requirements, PowerShell provides a rich set of tools for 
capturing and managing errors. The next few sections cover these tools and the tech-
niques for using them.
14.1.2
The $error variable and –ErrorVariable parameter
The point of rich error objects is that you can examine them after the error has 
occurred and possibly take remedial action. Of course, to do this you have to capture 
them first. In the previous section, I showed you how to redirect the error stream, but 
the problem with this approach is that you have to think of it beforehand. Because 
you don’t know when errors occur, in practice you’d have to do it all the time. Fortu-
nately, PowerShell performs some of this work for you and automatically “remembers 
the past,” at least as far as errors go. There’s a special variable 
$error
that contains a 
collection of the errors that occurred while the engine has been running. This collec-
tion is maintained as a circular bounded buffer. As new errors occur, old ones are dis-
carded, as shown in figure 14.4.
The number of errors that are retained is controlled by the 
$MaximumError-
Count
variable, which can be set to a number from 256 (the default setting) to 
32768.  The  collection  in 
$error
is an array (technically an instance of 
System.Collections.ArrayList
 that  buffers  errors  as  they  occur.  The  most 
recent error is always stored in 
$error[0]
NOTE
Although  it’s  tempting  to  think  that  you  could  just  set 
$MaximumErrorCount
to some very large value (32768 is the largest 
allowed) and never have to worry about capturing errors, in practice this 
strategy isn’t a good idea. Rich error objects also imply fairly large error 
objects. If you set 
$MaximumErrorCount
to too large a value, you won’t 
have any memory left. In practice, there’s usually no reason to set it to 
anything larger than the default, though you may set it to something 
smaller if you want to make more space available for other things. Also, 
even if you only have a few objects, these objects may be very large. If 
you find that this is the case for a particular script, you can change the 
maximum error count to something small. As an alternative, you could 
clean out all the entries in 
$error
by calling 
$error.Clear().
Change page order in pdf file - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
change page order pdf preview; reordering pages in pdf document
Change page order in pdf file - 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
change pdf page order reader; how to reorder pages in pdf online
E
RROR
HANDLING
561
Let’s explore using the 
$error
variable. You’ll start with the same error as before:
PS (1) > dir nosuchfile 
Get-ChildItem : Cannot find path 'C:\working\book\nosuchfile' be 
cause it does not exist.
At line:1 char:4 
+ dir  <<<< nosuchfile
You didn’t explicitly capture it, but it’s available in 
$error[0]
PS (2) > $error[0]
Get-ChildItem : Cannot find path 'C:\working\book\nosuchfile' 
because it does not exist.
At line:1 char:4 
+ dir  <<<< nosuchfile
with all of the error properties. For example, here’s the exception object:
PS (3) > $error[0].exception 
Cannot find path 'C:\working\book\nosuchfile' because it does 
not exist.
And here’s the target object that caused the error:
PS (4) > $error[0].targetobject 
C:\working\book\nosuchfile
Now let’s do something that will cause a second error:
PS (5) > 1/$null 
Attempted to divide by zero. 
At line:1 char:3 
+ 1/$ <<<< null
Here you have a division-by-zero error. 
$error currently contains five errors E1-E5. $MaximumErrorCount
is set to limit $error to five elements, so next error to be generated
will cause oldest error (E1) to be dropped.
1/$zero causes
error E6…
E1
E2
E3
E4
E5
E1
E2
E3
E4
E5
E6
E1
E2
E3
E4
E5
…which is added
to $error
E1 pushed off end
$error still contains five errors, but now they
are E2-E6. E2 will be dropped if another
error occurs.
Figure 14.4 How the 
$error
variable handles new errors 
when 
MaximumErrorCount
has been reached. The oldest 
error is dropped and the new 
one is added to the end.
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Convert Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. C# File: Split PDF; C# Page: Insert PDF pages
pdf change page order; change pdf page order online
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
splitting PDF pages and Files, adding a page into PDF document, deleting unnecessary page from PDF file and changing the position, orientation and order of PDF
pdf move pages; move pages in pdf acrobat
562
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
NOTE
The example here uses 
1/$null
. The reason for doing this 
instead of simply 1/0 is because the PowerShell interpreter does some-
thing called constant expression folding. It looks at expressions that con-
tain only constant values. When it sees one, it evaluates that expression 
once at compile time so it doesn’t have to waste time doing it again at 
runtime. This means that impossible expressions, such as division by 
zero, are caught and treated as parsing errors. Parsing errors can’t be 
caught and don’t get logged when they’re entered interactively, so they 
don’t make for a good example. (If one script calls another script and 
that script has one of these errors, the calling script can catch it, but the 
script being parsed can’t.)
Let’s verify that the second error is in 
$error[0]
. Look at the exception member:
PS (6) > $error[0].exception
Attempted to divide by zero.
Yes, it is. You’ll also verify that the previous error, “file not found,” is now in position 1:
PS (7) > $error[1].exception
Cannot find path 'C:\working\book\nosuchfile' because it does no 
t exist.
Again, yes, it is. As you can see, each new error shuffles the previous error down one 
element in the array. 
TIP
The key lesson to take away from this is that when you’re going to 
try to diagnose an error, you should copy it to a “working” variable so it 
doesn’t get accidentally shifted out from under you because you made a 
mistake in one of the commands you’re using to examine the error.
The 
$error
variable is a convenient way to capture errors automatically, but there are 
two problems with it:
• First, as we discussed earlier, 
$error
only captures a limited number of errors so 
important information may fall off the end of the buffer.
• Second, 
$error
contains all the errors that occur, regardless of where they 
came from or what command generated them, all mixed together in a single 
collection. You’ll find it hard to locate the information you need to diagnose a 
specific problem. 
The first problem can be worked around using redirection to capture all the errors, 
but that still doesn’t address mixing all the errors together. To deal with this second 
issue, when you want to capture all the errors from a specific command you use a 
standard parameter on all commands called 
-ErrorVariable
. This parameter names 
a variable to use for capturing all the errors that the command generates. Here’s an 
example.  This  command  generates  three  error  objects,  because  the  files  nofuss, 
nomuss, and nobother don’t exist:
C# Word - Process Word Document in C#
For example, you may change your Word document order from 1, 2, 3, 4, 5 to 3, 5, 4, 2,1 with C# coding. C#.NET: Extracting Page(s) from Word.
how to rearrange pages in pdf using reader; reorder pages pdf file
VB.NET Word: Change Word Page Order & Sort Word Document Pages
Note: if you are trying to change the order of a you want to see other VB.NET Word document editing controls, please read this Word reading page which has
pdf change page order acrobat; how to reorder pdf pages in reader
E
RROR
HANDLING
563
PS (1) > dir nofuss,nomuss,nobother -ErrorVariable errs 
Get-ChildItem : Cannot find path 'C:\Documents and Settings\bruc 
epay\nofuss' because it does not exist.
At line:1 char:4 
+ dir  <<<< nofuss,nomuss,nobother -ErrorVariable errs 
Get-ChildItem : Cannot find path 'C:\Documents and Settings\bruc 
epay\nomuss' because it does not exist.
At line:1 char:4 
+ dir  <<<< nofuss,nomuss,nobother -ErrorVariable errs 
Get-ChildItem : Cannot find path 'C:\Documents and Settings\bruc 
epay\nobother' because it does not exist.
At line:1 char:4 
+ dir  <<<< nofuss,nomuss,nobother -ErrorVariable errs
In the command, you specified the name of the error variable to place these records 
into: 
errs
NOTE
The argument to 
-ErrorVariable
is the name of the variable 
with no leading 
$
. If 
errs
had been written as 
$errs
, then the errors 
would’ve been stored in the variable named by the value in 
$errs
, not 
$errs
itself. Also note that the 
-ErrorVariable
parameter works like 
a tee—that is, the objects are captured in the variable, but they’re also 
streamed to the error output.  
Let’s verify that the errors were actually captured. First, the number of elements in 
$err
should be 3:
PS (2) > $errs.count 
3
It is. Now dump the errors themselves:
PS (3) > $errs
Get-ChildItem : Cannot find path 'C:\Documents and Settings\bruc 
epay\nofuss' because it does not exist.
At line:1 char:4 
+ dir  <<<< nofuss,nomuss,nobother -ErrorVariable errs 
Get-ChildItem : Cannot find path 'C:\Documents and Settings\bruc 
epay\nomuss' because it does not exist.
At line:1 char:4 
+ dir  <<<< nofuss,nomuss,nobother -ErrorVariable errs 
Get-ChildItem : Cannot find path 'C:\Documents and Settings\bruc 
epay\nobother' because it does not exist.
At line:1 char:4 
+ dir  <<<< nofuss,nomuss,nobother -ErrorVariable errs
They do, in fact, match the original error output.
NOTE
The errors should match the original output because they’re 
actually the same error objects. The 
-ErrorVariable
parameter (alias 
–ev
) captures references to each object written to the error stream. In 
effect, the same object is in two places at once—well, three if you count 
the default 
$error
variable.
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Embedded page thumbnails. In order to run the sample code, the following ops.MonochromeImageOptions.TargetResolution = 150F; // to change image compression
how to reverse page order in pdf; how to rearrange pdf pages reader
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
several PowerPoint document pages, or just change the position PPTXDocument(filepath); // Swap page 0 and page 1. doc PowerPoint Pages with a Certain Order in C#
change page order pdf; reverse page order pdf
564
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
Because there’s no need to see the object twice, you can use redirection to discard the 
written objects and save only the references stored in the specified variable. Let’s rerun 
the example this way:
PS (4) > dir nofuss,nomuss,nobother -ErrorVariable errs 2>$null
This time nothing was displayed; verify the error count:
PS (5) > $errs.count 
3
It’s 3 again, as intended. Let’s just check the 
TargetObject
member of the last error 
object to verify that it’s the filename nobother:
PS (6) > $errs[2].TargetObject 
C:\Documents and Settings\brucepay\nobother 
PS (7) >
Yes, it is. This example illustrates a more sophisticated way of capturing error objects 
than merely displaying them. In section 14.1.5, you’ll see an even more flexible way 
to control how errors are redirected.
All  of these  mechanisms provide useful tools  for handling collections of  error 
objects, but sometimes all you care about is that an error occurred at all. A couple of 
additional status variables, 
$?
and 
$LASTEXITCODE
, enable you to determine whether 
an error occurred.
14.1.3
Determining if a command had an error
Displaying errors is very useful; it lets the user know what happened. But scripts also 
need to know when an error has occurred so they can react properly. For example, a 
script shouldn’t try to remove a file if the 
cd
into the directory containing the file 
failed. PowerShell makes this easy by providing two error variables that capture the 
command status. First, to see if an error occurred when executing a command, a 
script can check the status of the variable 
$?
, a simple Boolean variable that holds the 
execution status of the last variable. 
NOTE
The use of the 
$?
variable is borrowed from the 
UNIX
shells. 
The 
$?
variable will be true if the entire operation succeeded, and false otherwise. For 
example, if any of the operations wrote an error object, then 
$?
will be set to false 
even if the error was discarded using redirection. This is an important point: it means 
that a script can determine whether an error occurred even if the error isn’t displayed. 
Here are some examples showing the use of 
$?
. First you call 
Get-Item
, passing in 
two item names that you know exist and one you know doesn’t exist:
PS (1) > Get-Item c:,nosuchfile,c:
Directory:
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
d--hs         6/13/2006  10:12 PM            C:\
C# Word - Sort Word Pages Order in C#.NET
or several Word document pages, or just change the position DOCXDocument(filepath); // Swap page 0 and page 1. doc Multiple Word Pages with a Certain Order in C#
how to move pages in pdf converter professional; pdf rearrange pages
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via Change PDF original password. In order to run the sample code, the following steps would be
how to rearrange pages in a pdf reader; move pdf pages online
E
RROR
HANDLING
565
Get-Item : Cannot find path 'C:\nosuchfile' because it does not 
exist.
At line:1 char:9 
+ Get-Item  <<<< c:,nosuchfile,c: 
d--hs         6/13/2006  10:12 PM            C:\
You get the expected error.
PS (2) > $?
False
And 
$?
is false. Now try the same command, but this time specify only the names of 
items that exist:
PS (3) > Get-Item c:,c:
Directory:
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
d--hs         6/13/2006  10:12 PM            C:\ 
d--hs         6/13/2006  10:12 PM            C:\
PS (4) > $?
True
This time, there are no errors and 
$?
is true.
Whereas the 
$?
variable only indicates success or failure, 
$LASTEXITCODE
con-
tains the exit code of the last command run. But this applies only to two types of 
commands: native or external commands and PowerShell scripts (but not functions). 
NOTE
On Windows, when a process exits it can return a single integer 
as its exit code. This integer is used to encode a variety of conditions, 
but the only one we’re interested in is whether it’s zero or non-zero. 
This convention is used by almost all programs. If they were successful, 
then their exit code is zero. If they encountered an error, then the exit 
code is non-zero.
PowerShell captures the exit code from a script or executable in 
$LASTEXITCODE
, and 
if that value is non-zero, it sets 
$?
to false. Let’s use 
cmd.exe
to demonstrate this. You 
can tell 
cmd
to execute a single command by passing it the 
/c
option along with the 
text of the command. In this example, the command you want to run is 
exit
, which 
takes a value to use as the exit code for the command:
PS (1) > cmd /c exit 0
You told 
cmd
to exit with code 0. Verify this by checking the values of 
$LASTEXIT-
CODE 
and 
$?
, respectively:
PS (2) > $LASTEXITCODE 
PS (3) > $?
True
566
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
As expected, the exit code was zero, and consequently 
$?
is true. Next try it with a 
non-zero value:
PS (4) > cmd /c exit 1
PS (5) > $LASTEXITCODE 
PS (6) > $?
False
This time, the exit code is 1, so 
$?
is set to false. You can do the same exercises with 
scripts. First create a script that exits with a zero exit code:
PS (7) > "exit 0" > invoke-exit.ps1 
PS (8) > ./invoke-exit 
PS (9) > $LASTEXITCODE 
PS (10) > $?
True 
$LASTEXITCODE is 0 and $? is true. Now try it with a non-zero value. 
PS (11) > "exit 25" > invoke-exit.ps1 
PS (12) > ./invoke-exit 
PS (13) > $LASTEXITCODE 
25 
PS (14) > $?
False
Now 
$LASTEXITCODE
contains the value the script exited with, which is 25, and 
$?
is 
set to false.
So far, we’ve looked at how to capture errors and how to detect when they occur. 
Next we’ll explore some of the methods PowerShell provides to control what happens 
when an error is generated.
14.1.4
Controlling the actions taken on an error
Earlier, we  talked about  the differences between terminating  and nonterminating 
errors. Sometimes you want to be able to turn nonterminating errors into terminat-
ing ones because the operation you’re performing is too critical to tolerate nontermi-
nating errors. For example, imagine you’re setting up a website for a user. You want to 
reuse a directory that had been previously used for someone else. First you want to 
remove all the old files and then install the new user’s files. Obviously, you can’t start 
installing the new files until all the old ones are deleted. In this situation, the failure 
to delete a file, which is normally a nonterminating error, must now be treated as a 
terminating error. The next step in the process can’t begin until the current step is 
100% complete.
The way to control whether errors are terminating or nonterminating is by setting 
the error action policy, which you do by setting the error action preference. This is a 
mechanism that allows you to control the behavior of the system when an error 
occurs. There are four possible settings for this preference: 
Continue
Silently-
Continue
Stop
, and 
Inquire
. These preferences are described in table 14.2.
E
RROR
HANDLING
567
There are two ways to set the error action preference: by setting the 
$ErrorAction-
Preference
variable as in
$ErrorActionPreference = "SilentlyContinue"
or by using the 
-ErrorAction
(or 
-ea
) parameter that’s available on all cmdlets, 
advanced functions, and advanced scripts.
TIP
When setting any of the preferences, you can use either the iden-
tifier string (such as 
"Stop"
) or its numeric equivalent (such as 
1
). 
The numeric value is more convenient for interactive use. If you do 
need to set a preference in a script for some reason, using the identifier 
string is preferred. 
Let’s see some examples of these preferences in action. Here’s a simple one. First run a 
command that has some nonterminating errors. You’ll use the 
Get-Item
cmdlet to 
get two items that exist and two items that don’t exist:
PS (1) > Get-Item c:\,nosuchfile,c:\,nosuchfile
Directory:
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
d--hs         6/13/2006  10:12 PM            C:\
Get-Item : Cannot find path 'C:\Documents and Settings\brucepay\ 
nosuchfile' because it does not exist.
At line:1 char:9 
+ Get-Item  <<<< c:\,nosuchfile,c:\,nosuchfile
Table 14.2 The supported identifiers and numeric equivalents for 
ErrorActionPreference
Identifier
Numeric value
Descriptions
Continue
2
This is the default preference setting. The error 
object is written to the output pipe and added to 
$error, and $? is set to false. Execution then 
continues at the next script line.
SilentlyContinue
0
When this action preference is set, the error mes-
sage isn’t written to the output pipe before continu-
ing execution. Note that it’s still added to $error, 
and $? is still set to false. Again, execution continues 
at the next line.
Stop
1
This error action preference changes an error from a 
nonterminating error to a terminating error. The error 
object is thrown as an exception instead of being 
written to the output pipe. $error and $? are still 
updated. Execution does not continue.
Inquire
3
Prompts the user requesting confirmation before 
continuing on with the operation. At the prompt, 
the user can choose to continue, stop, or suspend 
the operation.
568
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
d--hs         6/13/2006  10:12 PM            C:\
Get-Item : Cannot find path 'C:\Documents and Settings\brucepay\ 
nosuchfile' because it does not exist.
At line:1 char:9 
+ Get-Item  <<<< c:\,nosuchfile,c:\,nosuchfile
If you look at the output, you can see that there are two output objects and two error 
messages. You can use redirection to discard the error messages, making the code eas-
ier to read:
PS (2) > Get-Item c:\,nosuchfile,c:\,nosuchfile 2> $null
Directory:
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
d--hs         6/13/2006  10:12 PM            C:\ 
d--hs         6/13/2006  10:12 PM            C:\
Now you just see the output objects because you’ve sent the error objects to 
$null
You can use the 
-ErrorAction
parameter to do the same: 
PS (3) > Get-Item c:\,nosuchfile,c:\,nosuchfile ` 
>> -ea SilentlyContinue 
>>
Directory:
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
d--hs         6/13/2006  10:12 PM            C:\ 
d--hs         6/13/2006  10:12 PM            C:\
Again, the error messages aren’t displayed, but this time it’s because they aren’t being 
written at all instead of written and discarded. Finally, let’s try the “Stop” preference:
PS (4) > Get-Item c:\,nosuchfile,c:\,nosuchfile ` 
>> -ea Stop 
>>
Directory:
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
d--hs         6/13/2006  10:12 PM            C:\
Get-Item : Command execution stopped because the shell variable 
"ErrorActionPreference" is set to Stop: Cannot find path 
'C:\Documents and Settings\brucepay\nosuchfile' because it does not 
exist.
At line:1 char:9 
+ Get-Item  <<<< c:\,nosuchfile,c:\,nosuchfile `
This time, you see only one output message and one error message—the first one. 
This is because the error is treated as a terminating error and execution stops. Note 
that the error  message contains additional  text explaining  that execution  stopped 
because of the error action preference setting.
D
EALING
WITH
ERRORS
THAT
TERMINATE
EXECUTION
569
Of course, the 
-ErrorAction
parameter controls the error behavior for exactly 
one cmdlet. If you want to change the behavior for an entire script or even a whole 
session, you can do so by setting the 
$ErrorActionPreference
variable. Let’s redo 
the last example but use the variable instead of the parameter:
PS (5) > & { 
>> $ErrorActionPreference="Stop" 
>> Get-Item c:\,nosuchfile,c:\,nosuchfile 
>> } 
>>
Directory:
Mode                LastWriteTime     Length Name 
----                -------------     ------ ----
d--hs         6/13/2006  10:12 PM            C:\
Get-Item : Command execution stopped because the shell variable 
"ErrorActionPreference" is set to Stop: Cannot find path 
'C:\Documents and Settings\brucepay\nosuchfile' because it does not 
exist.
At line:3 char:9 
+ Get-Item  <<<< c:\,nosuchfile,c:\,nosuchfile
Again, the cmdlet stops at the first error instead of continuing. 
NOTE
In  this example,  note the use of the call operator 
&
with a 
scriptblock containing the scope for the preference setting. Using the 
pattern 
& { ...script  text...  }
, you can execute fragments of 
script code so that any variables set in the enclosed script text are dis-
carded at the end of the scriptblock. Because setting 
$ErrorAction-
Preference
has such a profound effect on the execution of the script, 
we’re using this technique to isolate the preference setting.
Through the 
-ErrorActionPreference
parameter and the 
$ErrorActionPrefer-
ence
variable, the script author has good control over when errors are written and 
when they’re terminating. Nonterminating errors can be displayed or discarded at 
will. But what about terminating errors? How does the script author deal with them? 
Sometimes you only want an error to terminate part of an operation. For example, 
you might have a script move a set of files using a series of steps for each move. If one 
of the steps fails, you want the overall move operation to terminate for that file, but 
you want to continue processing the rest of the files. To do this, you need a way to 
trap these terminating errors or exceptions, and that’s what we’ll discuss next.
14.2
D
EALING
WITH
ERRORS
THAT
TERMINATE
EXECUTION
This section will deal with the ways that PowerShell processes errors that terminate 
the current flow of execution, also called terminating errors. Here we’ll cover the lan-
guage elements for dealing with terminating errors and how you can apply these
Documents you may be interested
Documents you may be interested