c# pdf viewer itextsharp : Change pdf page order reader software application dll winforms html .net web forms Windows%20Powershell%20in%20Action%202nd%20Edition61-part1518

580
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
There are other important applications of the 
throw
statement in function defini-
tions—for instance, times when you want to make a function parameter mandatory. 
The 
throw
statement provides an efficient way to do this. Take a look at the follow-
ing function definition:
PS (11) > function hi ($name=$(throw '$name is required')) 
>> { "Hi $name" } 
>>
In this example, you’re using the 
throw
statement in a subexpression as the initializer 
for 
$name
. As you’ll recall from chapter 7, the initializer expression is executed if no 
value was provided on the command line. Try this function out, first with a value for 
name
:
PS (12) > hi Bob
Hi Bob
You receive the expected greeting. Next try it without a value:
PS (13) > hi 
$name is required 
At line:1 char:27 
+ function hi ($name=$(throw  <<<< '$name is required')) 
PS (14) >
You get a terminating error telling you that you have to provide a value for 
$name
This is a simple pattern that can be used to enforce mandatory parameters on func-
tions and scripts. And speaking of functions and scripts, all these error features are 
great for letting you know something is wrong, but how do you go about fixing the 
problem? This is our cue to segue into our next section: debugging.
14.3
D
EBUGGING
WITH
THE
HOST
API
S
The most basic form of debugging a script is to put statements in your script that dis-
play information about  the  execution of the script. Because you don’t  want your 
debugging output mixed into the rest of the output, you need mechanisms to display 
output directly on the console. You do this either by using the 
Write-Host
cmdlet or 
by using what are called the host 
API
s. These 
API
s are available through the 
$host 
variable. This object has the following members:
PS (1) > $host
Name             : ConsoleHost
Version          : 1.0.10568.0 
InstanceId       : 5c685c70-c950-4ce5-9aae-78331e4091a7 
UI               : System.Management.Automation.Internal.Host.In
ternalHostUserInterface 
CurrentCulture   : en-US 
CurrentUICulture : en-US 
PrivateData      :
Change pdf page order reader - 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 move pages within a pdf; how to move pages in pdf reader
Change pdf page order reader - 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
rearrange pdf pages; how to reorder pages in pdf
D
EBUGGING
WITH
THE
HOST
API
S
581
The information available from 
$host
includes the name of the host, its version, and 
so forth. The member that you’re most interested in is the 
UI
member. This member 
surfaces a number of methods that can be used to write messages directly to the host 
instead of the error stream. The ones you’re most interested in are the 
read
and 
write 
methods:
PS (2) > $host.ui | Get-Member [rw]*line*
TypeName: System.Management.Automation.Internal.Host.Internal 
HostUserInterface
Name                   MemberType Definition 
----                   ---------- ----------
ReadLine               Method     System.String ReadLine() 
ReadLineAsSecureString Method     System.Security.SecureStrin... 
WriteDebugLine         Method     System.Void WriteDebugLine(... 
WriteErrorLine         Method     System.Void WriteErrorLine(... 
WriteLine              Method     System.Void WriteLine(), Sy... 
WriteVerboseLine       Method     System.Void WriteVerboseLin... 
WriteWarningLine       Method     System.Void WriteWarningLin...
For example, if you want to write out a text message, you can use 
PS (3) > $host.ui.writeline("Hi there")
Hi there
to print out a simple string. Or you can use a more complex form of this method
PS (4) > $host.ui.writeline("red","green", "Hi there") 
Hi there
to print out a string in color. You can also get input from the user. To read a line from 
the console, use the 
ReadLine()
method:
PS (6) > $host.ui.readline()
Hi 
Hi
There’s a second level of host 
UI
available called 
RawUI
. This provides even more low-
level functions for accessing the console. For example, to read a single key from the 
console, you can use
PS (7) > $host.ui.rawui.readkey() 
g
VirtualKeyCode       Character ControlKeyState         KeyDown
--------------       --------- ---------------         -------
71               g               0            True
This returns information about the key code and other attributes of the keypress 
instead of simply the character.
The other way to access the host interfaces is through the 
Read-Host
and 
Write-
Host 
cmdlets. These cmdlets do approximately the same thing as the host methods 
but can be a bit easier to use. In particular, the 
Read-Host
cmdlet allows you to spec-
ify a prompt when reading:
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
PDF Document; Remove Password from PDF; Change PDF Permission Settings. Page: Insert PDF pages; VB.NET Page: Delete PDF VB.NET Annotate: PDF Markup & Drawing. XDoc
reorder pages in a pdf; change pdf page order preview
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
VB.NET PDF - How to Modify PDF Document Page in VB.NET. VB.NET Guide for Processing PDF Document Page and Sorting PDF Pages Order.
reordering pages in pdf; reverse pdf page order online
582
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
PS (8) > Read-Host "Enter some text"
Enter some text: some text 
some text
It even inserts a colon after your text when prompting.
Using the features described in this section, you can instrument your scripts in 
order to debug their behavior. Although this is a tried and true way of debugging, it 
requires you to make changes to your scripts to see what going on. PowerShell pro-
vides other mechanisms to find problems in your scripts. One of these features is 
“strict mode,” which is our next topic.
14.3.1
Catching errors with strict mode
PowerShell provides some built-in static and runtime checks to help you catch errors 
in your scripts. Static checks are performed at script load/compile time, and runtime 
checks are dynamic checks done at runtime.
NOTE
These features are similar to Option Explicit in Visual Basic or 
strict mode in 
PERL
and are named after the 
PERL
feature.
PowerShell v1 offered a limited set of checks, enabled through the 
Set-PSDebug 
cmdlet. PowerShell v2 introduced a new cmdlet—
Set-StrictMode
—which enables 
a much more comprehensive set of checks. In the next two sections we’ll look at what 
these checks are and how they can help you catch bugs in your code.
Using the v1 strict mode
In this section, we’ll cover the v1 strict mode checks. These checks are enabled using 
the 
Set-PSDebug
cmdlet with the 
-Strict
parameter. The syntax for this command 
is shown in figure 14.15.
This cmdlet allows you to turn on tracing and stepping, which act to provide a 
rudimentary debugger feature. We’re going to cover debugging in chapter 15 so we 
won’t discuss 
-Trace
or 
-Step
further at this point. The 
-Off
parameter turns off all 
features enabled through 
Set-PSDebug
. Let’s look at the set of checks performed in 
strict mode v1.
Set-PSDebug    [-Trace 0|1|2]    [-Step]    [-Strict]
Set-PSDebug    -Off
Set script tracing level:
0 = off, 1 = basic, 2 = full
Turn on strict mode 
Turn on stepping
Turn off all debugging features
Set-PSDebug cmdlet
Figure 14.15 The 
Set-PSDebug
cmdlet parameters. Among other things, 
this cmdlet is used to turn the v1 strict mode features on and off.
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the position of certain one PowerPoint page in an
how to rearrange pdf pages online; reorder pages in pdf document
C# Word - Sort Word Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several Word document pages, or just change the position of certain one Word page in an
move pdf pages in preview; reordering pdf pages
D
EBUGGING
WITH
THE
HOST
API
S
583
Catching undefined variables with strict mode
A common source of errors in scripts is the use of undefined or uninitialized variables, 
usually because you misspelled the variable’s name. As in many other scripting lan-
guages, in PowerShell if a variable is undefined, it’s treated as though it was defined 
and set to the value 
$null
. You can test this behavior with a simple expression:
PS (1) > 2 * $nosuchvariable 
0
In this expression, 
$nosuchvariable
isn’t defined. This means that it’s treated as 
though it were 
$null
. Because 
$null
in a numeric expression is treated as zero, the 
whole expression evaluates to zero. You should note that the variable is only treated as 
though it were 
$null
. This doesn’t mean that a variable named 
$nosuchvariable
is 
actually created as a side effect. You can verify this using 
dir
with the variable pro-
vider to see if the variable is defined:
PS (2) > dir variable:\nosuchvariable
Get-ChildItem : Cannot find path 'nosuchvariable' because it doe 
s not exist.
At line:1 char:4 
+ dir  <<<< variable:\nosuchvariable
Now that you’ve seen the default behavior for variables that don’t exist, let’s turn on 
strict mode and try it again. First enable v1 strict mode:
PS (3) > Set-PSDebug –Strict
Try evaluating the same expression:
PS (4) > 2 * $nosuchvariable
The variable $nosuchvariable cannot be retrieved because it has 
not been set yet.
At line:1 char:19 
+ 2 * $nosuchvariable <<<<
This time, you get an error telling you that the variable hasn’t been defined. So, define it
PS (5) > $nosuchvariable=13
and run the command again:
PS (6) > 2 * $nosuchvariable 
26
Now you get the expected result. If you delete the variable using the provider
PS (7) > del variable:\nosuchvariable
and run the expression for a third time
PS (8) > 2 * $nosuchvariable
The variable $nosuchvariable cannot be retrieved because it has 
not been set yet.
At line:1 char:19 
+ 2 * $nosuchvariable <<<<
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# users to reorder and rearrange multi-page Tiff file Tiff image management library, you can easily change and move pages or make a totally new order for all
pdf page order reverse; how to move pages in a pdf document
C# Word - Process Word Document in C#
various Word document processing implementations using C# demo codes, such as add or delete Word document page, change Word document pages order, merge or
change page order in pdf online; move pages within pdf
584
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
you’re back to the error message. This mechanism is quite helpful in finding bugs in 
scripts. Unfortunately, the way it’s implemented, it will only catch these errors if the 
problematic statement is actually executed. 
There’s also one type of uninitialized variable use that won’t be caught even at run-
time with v1 strict mode, and that is the use of uninitialized variables when double-
quoted strings are expanded. This means that, even if you’re catching things like this
$result = 2 + $nosuchvariable
no error will be raised for
$result = "the variable is $nosuchvariable"
so you may still have hidden bugs in this type of construct.
Some of the shortcomings of strict mode in v1 were addressed in PowerShell v2 
by adding some additional types of checks. Let’s see what was added.
14.3.2
The Set-StrictMode cmdlet in PowerShell v2
The v1 strict mode feature enabled through 
Set-PSDebug -Strict
is useful, but the 
set of checks is limited to undefined variables. PowerShell v2 introduced a new ver-
sion of strict mode and a new cmdlet, 
Set-StrictMode
, to enable additional checks. 
The syntax for this cmdlet is shown in figure 14.16.
The 
-Version
parameter takes either 1 or 2 as an argument controlling whether 
v1 or v2 checks are enabled. Version 2 strict mode includes the undefined variable 
check from v1 and adds some additional checks. In the next few sections, we’ll look 
at what these new checks do.
Catching uninitialized variable use in string expansions
As mentioned earlier, strict mode in v1 only caught references to uninitialized vari-
ables in script text. It didn’t catch the use of uninitialized variables in string expan-
sions.  Strict  mode  v2  fixes  this  and  the  use  of  uninitialized  variables  is  caught 
everywhere. Let’s look at an example. To refresh, in nonstrict mode, when you refer-
ence a nonexistent variable it’s treated as being equivalent to 
$null
:
PS (1) > $nosuchvariable 
PS (2) >
Set-StrictMode  [-Version <Int32>]
Set-StrictMode  -Off
Turn on strict mode, optionally specifying version 1 or version 2
checks; use string "latest" to select newest set of checks 
Turn off strict mode
Figure 14.16 The 
Set-StrictMode
cmdlet and its parameters. This is a 
new cmdlet in version 2 that enables 
additional compile-time and runtime 
checks processing a script.
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
Enable C#.NET developers to change the page order of source PDF document file; Allow C#.NET developers to add image to specified area of source PDF document
reorder pages in pdf; how to move pages in pdf acrobat
RasterEdge.com General FAQs for Products
speaking, you will receive a copy of email containing order confirmation and dedicated to provide powerful & profession imaging controls, PDF document, image
rearrange pages in pdf; pdf reorder pages
D
EBUGGING
WITH
THE
HOST
API
S
585
Now turn on strict mode v1 and reference the variable again
PS (2) > Set-PSDebug -Strict
PS (3) > $nosuchvariable 
The variable '$nosuchvariable' cannot be retrieved because it 
has not been set.
At line:1 char:16 
+ $nosuchvariable <<<<
+ CategoryInfo          : InvalidOperation: (nosuchvariable
:Token) [], RuntimeException
+ FullyQualifiedErrorId : VariableIsUndefined
and you get the uninitialized variable message as expected. Now put the string in quotes
PS (4) > "$nosuchvariable"
PS (5) >
and it expands the string with no errors. Turn on strict mode v2 and try the string 
expansion
PS (5) > Set-StrictMode -Version 2
PS (6) > "$nosuchvariable"
The variable '$nosuchvariable' cannot be retrieved because it 
has not been set.
At line:1 char:16 
+ "$nosuchvariabl <<<< e"
+ CategoryInfo          : InvalidOperation: (nosuchvariable
:Token) [], RuntimeException
+ FullyQualifiedErrorId : VariableIsUndefined
and you also get the uninitialized variable error in the string expansion case. Next 
we’ll look at some of the new strict mode v2 features.
Catching attempts to read nonexistent properties
To have appropriately shell-like behavior, by default PowerShell allows you to try 
dereferencing nonexistent properties. That means you can do things like display a 
mixed  collection  of 
[System.IO.FileInfo]
and 
[System.IO.DirectoryInfo] 
objects, including a reference to the 
Length
property that doesn’t exist for 
[Sys-
tem.IO.DirectoryInfo]
objects. Imagine how annoying it’d be to type 
dir
and get 
a lot of “property not found” errors. Try running
dir | foreach { $_.name + " " + $_.length }
in your home directory with strict mode v2 turned on and you’ll see what I mean.
NOTE
This only applies to explicit property references in script text. 
Cmdlets still ignore missing properties even when strict mode v2 is turned 
on. The interactive environment is pretty much unusable otherwise.
Try a simple example. First turn strict mode off, then get a 
[DateTime]
object into 
the variable 
$date
:
586
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
PS (1) > Set-StrictMode -Off
PS (2) > $date = Get-Date
Now reference a nonexistent property
PS (3) > $date.nosuchproperty
PS (4) >
and no error is raised. You can verify that this will not be caught with strict mode v1:
PS (4) > Set-StrictMode -Version 1
PS (5) > $date.nosuchproperty 
PS (5) >
You get no error, as before. Now turn on strict mode v2 and try accessing the property:
PS (6) > Set-StrictMode -Version 2
PS (7) > $date.nosuchproperty 
Property 'nosuchproperty' cannot be found on this object. Make 
sure that it exists.
At line:1 char:7 
+ $date. <<<< nosuchproperty
+ CategoryInfo          : InvalidOperation: 
(.:OperatorToken) [], RuntimeException
+ FullyQualifiedErrorId : PropertyNotFoundStrict
This time you get an error. As with the variable check, property checks will help catch 
typos in your script. It would be better if you could catch them at compile time, but 
then you’d  need  to  know  the types  of all the expressions. Because PowerShell  is 
dynamically typed, that isn’t really possible.
NOTE
But what about checking against the type-constraints on vari-
ables, you might ask? Strict mode could include this kind of check, but 
it can’t do a complete check because PowerShell allows extensions on 
instances as well as types. For example, when you look at a file entry 
in PowerShell, you see a 
Mode
property. The underlying .
NET
type 
[System.IO.FileInfo]
doesn’t have a property with this name. The 
Mode
property is one of the properties added by the PowerShell run-
time. Because these properties can be added at runtime, even for a 
type-constrained variable, the most you could say is that the member 
probably won’t exist by the time the statement is executed. Only the 
runtime check is guaranteed to be correct.
Checking for functions called like methods
An extremely common source of errors for experienced programmers is to call func-
tions in the same way you would in other languages, or in the same way methods are 
called in PowerShell. Let’s see this in action. Turn off strict mode (or set it to v1):
PS (1) > Set-StrictMode -Off
D
EBUGGING
WITH
THE
HOST
API
S
587
Then define a function that looks like this:
PS (2) > function divide ($x,$y) { $x / $y }
This function takes two arguments, divides the first by the second, and returns the 
result. Now let’s call it like a method with parentheses around a function. This is how 
you’d call a function in a language like 
C
#:
PS (3) > divide(9, 3)
Method invocation failed because [System.Object[]] doesn't 
contain a method named 'op_Division'.
At line:1 char:31 
+ function divide ($x,$y) { $x / <<<<  $y }
+ CategoryInfo          : InvalidOperation: 
(op_Division:String) [], RuntimeException
+ FullyQualifiedErrorId : MethodNotFound
What happens is that you get a very surprising error. You know that numbers can be 
divided, so why did this fail? By putting the two arguments in parentheses, you’re telling 
the system to pass a single argument, which is an array of two numbers. We talked about 
this problem in section 7.2.1. Now turn on strict mode v2, and try it again:
PS (4) > Set-StrictMode -Version 2
PS (5) > divide(9, 3)
The function or command was called as if it were a method. 
Parameters should be separated by spaces. For information 
about parameters, see the about_Parameters Help topic.
At line:1 char:7 
+ divide <<<< (9, 3)
+ CategoryInfo          : InvalidOperation: (:) [], Runtime
Exception
+ FullyQualifiedErrorId : StrictModeFunctionCallWithParens
Now you get a very prescriptive error message explaining exactly what’s gone wrong. 
Follow the instructions, rewriting the function call, removing the parameters, and 
separating it with spaces instead of a comma; then try running it again:
PS (6) > divide 9 3 
PS (7) >
This time it works.
This technique may seem like a trivial, almost silly check, but this issue has caused 
a lot of problems for a lot of people, including members of the PowerShell team. 
Checking for empty variable references in strings
The final check is another corner-case check, this time for empty delimited variables. 
A delimited variable is something like 
${a  variable}
, which allows you to have 
characters in a variable name that are normally not allowed. For example:
PS (1) > Set-StrictMode -off
PS (2) > ${a variable} = "foo"
588
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
The other important use for delimited variables is in string expansion, where the vari-
able name being expanded could be confused with the rest of the string:
PS (3) > $prefix = "foo"; "The word is ${prefix}bar" 
The word is foobar
Here the variable 
${prefix}
is expanded properly. Without the braces, the runtime 
would’ve tried to expand 
$prefixbar
and failed. Now let’s move on to the problem-
atic scenario. Normally, outside of a string, if no names are specified between the 
braces, an error will occur, strict mode or not:
PS (4) > ${}
Empty ${} variable reference, there should be a name between the
braces.
At line:1 char:1 
 <<<< ${}
+ CategoryInfo          : ParserError: (:) [], 
ParentContainsErrorRecordException
+ FullyQualifiedErrorId : EmptyVariableReference
But in string expansions, it expands into 
$
, as in
PS (5) > "The word is ${}bar"
The word is $bar
A minor error to be sure, but it’s one you can detect at compile time (at least in Power-
Shell v2), so you check for it. Turn on v2 strict mode and rerun the command
PS (6) > Set-StrictMode -Version 2
PS (7) > "The word is ${}bar"
Braced variable name cannot be empty. 
At line:1 char:21 
+ "The word is ${}bar" <<<<
+ CategoryInfo          : InvalidOperation: (:) [], Runtime
Exception
+ FullyQualifiedErrorId : EmptyBracedVariableName
and now you get the error.
Applying strict mode v2 to scripts
You now know what the new checks are—let’s talk about when to apply them. In gen-
eral, it’s recommended that new code be written to be strict mode v2 “clean.” In other 
words, the code should produce no errors when strict mode v2 is turned on. The temp-
tation is to leave it on all the time. Unfortunately, this approach can break a lot of script 
code. Many scripts are written to take advantage of the default property dereference 
behavior. This means that a lot of fixing may need to be done. There are also cases 
where rewriting the code to not depend on this behavior can be very messy—the code 
would have to either explicitly check for the existence of a property before trying to 
access it, or explicitly trap the exception and ignore it. Consider the example at the 
beginning of the section that addressed catching references to nonexistent properties:
dir | foreach { $_.name + " " + $_.length }
D
EBUGGING
WITH
THE
HOST
API
S
589
This code results in an error every time 
dir
returns a directory object. To make this 
work in strict mode v2, you’d have to do something like this
dir | foreach { $_.name + " " + $(try { $_.length } catch { $null })}
where the 
try/catch
statement is used to process the error. In this code, if there’s no 
exception, then the value of the property is returned. If there is an exception, the 
catch
block returns 
$null
. (At least the expression-oriented nature of the Power-
Shell language simplifies this example instead of requiring intermediate variables and 
an 
if
statement.)
14.3.3
Static analysis of scripts
Most of the checks performed in strict mode are only applied at runtime, but there 
are some other checks you can do statically before you ever run the script. This was 
made possible in PowerShell v2 by the introduction of the PowerShell tokenizer 
API
a .
NET
class that takes the text of a PowerShell script and breaks it down into pieces 
called tokens. Tokens correspond to the types of elements found in the PowerShell 
language, which include things like keywords, operators, and so on—basically all the 
things we talked about in chapters 2 through 8. Unfortunately, this mechanism isn’t 
packaged in a convenient way for scripting. It was designed for the PowerShell ISE, as 
you’ll see in the next chapter. But, with a little work, it’s still usable from a script. First 
we’ll discuss how to use the 
API
. We’ll start by tokenizing a small piece of script text. 
(If you have strict mode turned on, you’ll have to turn it off for these examples.) Put 
the text you want to tokenize into a variable:
PS (2) > $script = "function abc ($x) {dir; $x + 1}"
The tokenizer returns two things: the tokens that make up the script and a collection 
of any errors encountered while parsing the script. Because the 
API
is designed for use 
from languages that can’t return multiple values, you also need to create a variable to 
hold these errors:
PS (3) > $parse_errs = $null
Now you’re ready to tokenize the script. Do so by calling the static method 
Token-
ize()
on the 
PSParser
class as follows:
PS (4) > $tokens = [System.Management.Automation.PSParser]::Tokenize( 
>>   $script, 
>>   [ref] $parse_errs)
This code will put the list of tokens in the 
$tokens
variable and any parse errors will 
be  placed  into  a  collection  in 
$parse_errs
 Now  dump  these  two  vari-
ables—
$parse _errs
—to the error stream and 
$tokens
to the output stream:
>> $parse_errs | Write-Error 
>> $tokens | Format-Table -auto type,content,startline,startcolumn 
>>
Documents you may be interested
Documents you may be interested