c# pdf viewer itextsharp : Move pages in a pdf file Library application class asp.net html web page ajax Windows%20Powershell%20in%20Action%202nd%20Edition67-part1524

640
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
$args is 2 
DEBUG:    1+ foreach ($i in 1..3) {foo $i} 
DEBUG:    1+ function foo {"`$args is " + $args} 
$args is 3
In this output, you can only see the line that’s being executed. You don’t see when you 
enter the actual function. To get this extra information, you need to turn on full tracing:
PS (8) > Set-PSDebug -Trace 2 
DEBUG:    1+ Set-PSDebug -Trace 2
In this mode, you also see the function calls:
PS (9) > foreach ($i in 1..3) {foo $i}
DEBUG:    1+ foreach ($i in 1..3) {foo $i} 
DEBUG:    1+ foreach ($i in 1..3) {foo $i} 
DEBUG:     ! CALL function 'foo'
DEBUG:    1+ function foo {"`$args is " + $args} 
$args is 1 
DEBUG:    1+ foreach ($i in 1..3) {foo $i} 
DEBUG:     ! CALL function 'foo'
DEBUG:    1+ function foo {"`$args is " + $args} 
$args is 2 
DEBUG:    1+ foreach ($i in 1..3) {foo $i} 
DEBUG:     ! CALL function 'foo'
DEBUG:    1+ function foo {"`$args is " + $args} 
$args is 3
In addition to function calls, full tracing adds to the display by showing variable 
assignments. Let’s redefine the function so that it performs a variable assignment. 
We’ll split it across multiple lines so the trace is a bit clearer:
PS (10) > function foo { 
>> $x = $args[0] 
>> "x is $x" 
>> } 
>>
DEBUG:    1+ function foo {
And run it again:
PS (11) > foreach ($i in 1..3) {foo $i} 
DEBUG:    1+ foreach ($i in 1..3) {foo $i} 
DEBUG:    1+ foreach ($i in 1..3) {foo $i} 
DEBUG:     ! CALL function 'foo'
DEBUG:    2+ $x = $args[0]
DEBUG:     ! SET $x = '1'.
DEBUG:    3+ "x is $x" 
x is 1 
DEBUG:    1+ foreach ($i in 1..3) {foo $i} 
DEBUG:     ! CALL function 'foo'
DEBUG:    2+ $x = $args[0]
DEBUG:     ! SET $x = '2'.
DEBUG:    3+ "x is $x"
Move pages in a 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
pdf reverse page order online; change pdf page order reader
Move pages in a 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 page order pdf; how to move pages in pdf
P
OWER
S
HELL
SCRIPT
DEBUGGING
FEATURES
641
x is 2 
DEBUG:    1+ foreach ($i in 1..3) {foo $i} 
DEBUG:     ! CALL function 'foo'
DEBUG:    2+ $x = $args[0]
DEBUG:     ! SET $x = '3'.
DEBUG:    3+ "x is $x" 
x is 3
You can see that for each iteration in the loop, tracing shows the following:
• Loop iteration
• Function call
• Statement doing the assignment
• Actual assignment to 
$x
, including the value assigned
• Statement that emits the value
The value displayed is the string representation of the object being assigned, trun-
cated to fit in the display. It depends on the 
ToString()
method defined for that 
object to decide what to display. This isn’t always as useful as you’d like. For example, 
with the hashtable
PS (12) > $a = @{x=1; y=2}
DEBUG:    1+ $a = @{x=1; y=2}
DEBUG:     ! SET $a = 'System.Collections.Hashtable'.
it shows you the type of the object, but nothing about its actual value. For arrays and 
other collections, it shows you a truncated representation of the elements of the list. 
So, for an array of 100 numbers, you see this:
PS (13) > $a = 1..100 
DEBUG:    1+ $a = 1..100 
DEBUG:     ! SET $a = '1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
18 19 20 21 22 23...'.
Overall, script tracing is pretty effective, but sometimes you still need to add calls to 
Write-Host
to your script to help with debugging, as we mentioned in chapter 14.
Debugging scripts run by other people
The other thing we mentioned in chapter 14 was the transcript capability. Transcripts 
combined with tracing provide a valuable tool to help with debugging scripts that are 
being run by other people in your organization. By capturing the trace output in a 
transcript file, you can get a much better idea of what a script is doing in the other 
user’s environment.
Tracing is also valuable in debugging remote scripts where you can’t use the ISE 
debugger, as you’ll see later in this chapter.
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
random pages can be deleted from PDF file as well. Sorting Pages. RasterEdge XDoc.PDF allows you to easily move PDF document pages position, including sorting
how to move pages around in a pdf document; rearrange pages in pdf
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Using this C#.NET Tiff image management library, you can easily change and move the position of any two or more Tiff file pages or make a totally new order for
pdf reorder pages; how to rearrange pages in a pdf document
642
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
Stepping through statement execution
The next debugging feature we’ll look at is the mechanism that PowerShell provides 
for stepping through a script.
NOTE
Like the tracing mechanism, this stepping feature is also a car-
ryover from PowerShell v1. It’s largely subsumed by the 
ISE
debugger, 
but there are some advanced scenarios, such as debugging dynamically 
generated code, where it’s still very useful.  For  example, if you use 
[ScriptBlock]::Create()
to dynamically generate a scriptblock, 
you can’t set a breakpoint because you don’t have a line number in a 
file to use to set the breakpoint. More on this later.
You turn stepping on by calling the 
Set-PSDebug
cmdlet with the 
-Step
parameter:
PS (14) > Set-PSDebug -Step
DEBUG:    1+ Set-PSDebug -Step
Rerun the 
foreach
loop and take a look at the prompt that’s displayed:
PS (15) > foreach ($i in 1..3) {foo $i}
Continue with this operation?
1+ foreach ($i in 1..3) {foo $i}
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend 
[?] Help(default is "Y"): y 
DEBUG:    1+ foreach ($i in 1..3) {foo $i}
Continue with this operation?
1+ foreach ($i in 1..3) {foo $i}
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend 
[?] Help(default is "Y"): y 
DEBUG:    1+ foreach ($i in 1..3) {foo $i}
DEBUG:     ! CALL function 'foo'
Continue with this operation?
The interpreter displays the line to be executed, then asks the user to select Yes, Yes to 
All, No, or No to All. The default is Yes.
If you answer Yes, that line will be executed and you’ll be prompted as to whether 
you want to execute the next line. If you answer Yes to All, then step mode will be 
turned off and execution will continue normally. If you answer either No or No to 
All, the current execution will be stopped and you’ll be returned to the command 
prompt. There’s no difference in the behavior between No and No to All. The fol-
lowing shows the message you’ll see if you enter No:
Continue with this operation?
2+ $x = $args[0]
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend 
[?] Help(default is "Y"): y 
DEBUG:    2+ $x = $args[0]
C# Word - Sort Word Pages Order in C#.NET
C# DLLs: Move Word Page Position. Add references: Swap Two Word Pages Position Using C#. You may choose two pages of Word file and exchange their position.
how to move pages around in pdf file; reverse pdf page order online
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
splitting. C# DLLs: Move PowerPoint Page Position. C#. You may choose two pages of PowerPoint file and exchange their position. String
reorder pages in pdf preview; reorder pdf page
P
OWER
S
HELL
SCRIPT
DEBUGGING
FEATURES
643
DEBUG:     ! SET $x = '2'.
Continue with this operation?
3+ "x is $x" 
}
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend 
[?] Help(default is "Y"): l 
WriteDebug stopped because the DebugPreference was 'Stop'. 
At line:1 char:23 
+ foreach ($i in 1..3) {f <<<< oo $i}
PS (16) >
There’s one more option in the stepping list that we haven’t talked about yet: Sus-
pend. This option is interesting enough to cover in its own section.
15.4.2
Nested prompts and the Suspend operation
One of the most interesting aspects of dynamic language environments is that a script 
can recursively call the interpreter. You’ve already seen this with the 
Invoke-Expres-
sion
cmdlet in chapter 11. A variation is to recursively call the interpreter interactively. 
This means that you are, in effect, suspending the currently running command and 
starting a new nested session. This sequence of events is illustrated in figure 15.23.
In the figure, you see that the user makes a call to the engine using the interfaces 
provided by the host application. In this case, instead of returning to the caller, the 
engine calls back to the host indicating that it should enter a nested-prompt mode. 
While in nested-prompt mode, because the original command pipeline is still active 
(the engine never returned to the host), the host must now use nested pipelines to exe-
cute commands. This continues until the engine calls the 
Exit()
API
, usually in 
response to a request from the user, and the host can resume the original pipeline.
The net effect of all this is that you can suspend the currently executing PowerShell 
pipeline and interact with PowerShell at the nested prompt. Why is this interesting?
PowerShell
host 
application
Host invokes pipeline that suspends execution
Engine calls EnterNestedPrompt ()
PowerShell
engine
Host invokes nested pipelines
Engine calls Exit() 
Host sends exit command to engine
Host resumes non-nested pipeline calls
Figure 15.23 Suspending execution and entering a nested prompt requires oper-
ations on both the host and engine sides of the session.
C# PDF insert text Library: insert text into PDF content in C#.net
int pageIndex = 0; // Move cursor to (400F, 100F). If you want to add a text string to PDF file, please try this C# demo. // Open a document.
rearrange pdf pages; reorder pages of pdf
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Rapidly and multiple PDF document (pages) creation and edit methods append, and split PDF files; insert, delete, move, rotate, copy and paste PDF file page
change page order pdf; move pages in pdf
644
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
Because this allows you to examine and modify the state of the suspended session sim-
ply by using the regular PowerShell commands you’re used to. Instead of creating a 
whole new language just for debugger operations, you use the same language you’re 
debugging. This feature is the core of all of the debugging capabilities in PowerShell.
There are a couple ways to enter a nested-prompt session, as you’ll see in the next 
two  sections.
Suspending a script while in step mode
Creating a nested interactive session is what the Suspend operation prompt shown 
during stepping does. Let’s try it out. First, turn on stepping:
PS (1) > Set-PSDebug -Step
Then run a statement that should loop 10 times, printing out the numbers from 1 to 10:
PS (2) > $i=0; while ($i++ -lt 10) { $i }
Continue with this operation?
1+ $i=0; while ($i++ -lt 10) { $i }
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend 
[?] Help(default is "Y"): 
DEBUG:    1+ $i=0; while ($i++ -lt 10) { $i }
You’ll see all of the intermediate blather. Keep stepping until the first number is dis-
played:
Continue with this operation?
1+ $i=0; while ($i++ -lt 10) { $i }
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend 
[?] Help(default is "Y"): 
DEBUG:    1+ $i=0; while ($i++ -lt 10) { $i }
Continue with this operation?
1+ $i=0; while ($i++ -lt 10) { $i }
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend 
[?] Help(default is "Y"): 
DEBUG:    1+ $i=0; while ($i++ -lt 10) { $i } 
1
At this point,  use the  Suspend operation to suspend  stepping.  When prompted, 
respond by typing 
s
followed by Enter instead of just pressing Enter:
Continue with this operation?
1+ $i=0; while ($i++ -lt 10) { $i }
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend 
[?] Help(default is "Y"): y 
DEBUG:    1+ $i=0; while ($i++ -lt 10) { $i } 
1
Continue with this operation?
1+ $i=0; while ($i++ -lt 10) { $i }
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend 
[?] Help(default is "Y"): s 
1>> PS (3) >
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
Certainly, random pages can be deleted from PDF file as well. PDF Page sorting. RasterEdge XDoc.PDF allows you to easily move PDF document pages position in VB
how to move pages in pdf acrobat; how to change page order in pdf acrobat
C# PDF Library SDK to view, edit, convert, process PDF file for C#
Rapidly load, create, convert and edit PDF document (pages) in C# append, and split PDF files; insert, delete, move, rotate, copy and paste PDF file page.
how to reorder pages in a pdf document; reverse page order pdf
P
OWER
S
HELL
SCRIPT
DEBUGGING
FEATURES
645
You immediately receive a new prompt. Notice that the prompt has changed to indi-
cate that you’re now working in a nested prompt, or subshell.
NOTE
The way to  tell when you’re in  nested-prompt mode is to 
check  the 
$NestedPromptLevel
variable. If you’re in a nested 
prompt, this variable will be greater than 0.
In this nested prompt, you can do anything you’d normally do in PowerShell. In this 
case, you want to inspect the state of the system. For example, let’s check to see what 
the variable 
$i
is set to. Because the last statement executed was 
$i++
and the printed 
value for 
$i
was 1, the value should be 2:
1>> PS (4) > $i
2
In fact, it is. But you’re not limited to inspecting the state of the system: you can 
change it. In this case, let’s make the loop end early by setting the value to something 
larger than the terminating condition. Set it to 100:
1>> PS (5) > $i=100 
1>> PS (6) > $i 
100
Now exit the nested-prompt session with the normal 
exit
statement. This returns you 
to the previous level in the interpreter where, because you’re stepping, you’re prompted 
to continue. Respond by typing 
a
followed by Enter for 
[A] Yes to All
to get out 
of step mode:
1>> PS (7) > exit
Continue with this operation?
1+ $i=0; while ($i++ -lt 10) { $i }
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend 
[?] Help(default is "Y"): a 
DEBUG:    1+ $i=0; while ($i++ -lt 10) { $i } 
100
There are two things to notice here: the loop terminates, printing only one number, 
and that value is the value you set 
$i
to, which is 100. Check one more time to verify 
that 
$i
is 100:
PS (8) >  $i 
100
Using the Suspend feature, you can stop a script at any point and examine or modify 
the state of the interpreter. You can even redefine functions in the middle of execu-
tion (although you can’t change the function that’s currently executing). This makes 
for a powerful debugging technique, but it can be annoying to use stepping all the 
time. This is where having a real debugger makes all the difference. But before we get 
to that, there’s one more thing you need to look at: the mechanics of how a break-
point works.
646
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
Creating a breakpoint command
In section 14.3.1, we looked at the 
$host
variable and talked about how you can use 
it to write your debugging messages. The 
$host
variable has another method that can 
be used for debugging called 
EnterNestedPrompt()
. This is the method we men-
tioned earlier when we looked at the stepping feature on 
Set-PSDebug
. Using this 
method, you can start a nested session at any point you want, and that point can be 
used approximately like a breakpoint. (Don’t worry, there are real breakpoints—we’ll 
get there.) To cause your script to break, you insert a call to 
EnterNestedPrompt() 
at the desired location and, when it’s hit, a new interactive session starts. Let’s try it 
out. You’ll execute a loop  that counts from 0 to 9.  In this loop, when the loop 
counted is equal to 4, you’ll call 
EnterNestedPrompt()
:
PS (1) > for ($i=0; $i -lt 10; $i++) 
>> { 
>>     "i is $i" 
>>     if ($i -eq 4) {
When execution gets to this point, you’ll output the string “*break*” and then enter a 
nested-prompt level:
>>         "*break*" 
>>         $host.EnterNestedPrompt() 
>>     } 
>> } 
>> 
i is 0 
i is 1 
i is 2 
i is 3 
i is 4
Now 
$i
is equal to 4, so you hit the breakpoint code. As in the stepping case, you can 
examine and change the state of the interpreter
*break* 
1>> PS (2) > $i 
1>> PS (3) > $i=8
and use 
exit
to resume the top-level execution thread:
1>> PS (4) > exit 
i is 9 
PS (6) >
Let’s see how you can use this feature to create a 
breakpoint
command. Once again, 
you’ll take advantage of scriptblocks to add a way to trigger the breakpoint based on a 
particular condition:
PS (1) > function bp ([scriptblock] $condition) 
>> { 
>>     if ($condition) 
>>     {
T
HE
P
OWER
S
HELL
V
DEBUGGER
647
>>         if (. $condition) 
>>         {
If the 
$condition
parameter to 
bp
is not null, evaluate it. If it evaluates to 
$true
then execute the breakpoint and enter a nested-shell level:
>>             $host.UI.WriteLine("*break*") 
>>             $host.EnterNestedPrompt() 
>>         } 
>>     } else { 
>>         $host.UI.WriteLine("*break*") 
>>         $host.EnterNestedPrompt() 
>>     } 
>> } 
>>
PS (2) > for ($i=0; $i -lt 10; $i++) 
>> { 
>>     . bp {$i -eq 5}
Here you’re inserting a breakpoint that will cause execution to break when 
$i
is equal 
to 5. Note that you’re dot-sourcing the 
bp
function. This is because you want it to be 
executed in the current scope, allowing you to change the state of the loop variable:
>>     "`$i is $i" 
>> } 
>> 
$i is 0 
$i is 1 
$i is 2 
$i is 3 
$i is 4
*break*
You hit the breakpoint. Increment the loop variable so that 5 is never displayed, and 
exit the nested-prompt level and resume execution:
1>> PS (3) > $i++ 
1>> PS (4) > exit 
$i is 6 
$i is 7 
$i is 8 
$i is 9 
PS (5) >
The loop exits, never having printed 5.
Now that you have a basic idea of how the debugging environment works, let’s 
move on to the main event and look at debugging from the 
ISE
.
15.5
T
HE
P
OWER
S
HELL
V
DEBUGGER
With PowerShell v2, a powerful new debugger was added to the product. In this sec-
tion, we’ll start with how to use the debugger from the 
ISE
and then move on to what 
you can do with command-line debugging.
648
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
15.5.1
The graphical debugger
As you’ve seen, the 
ISE
provides an integrated environment for editing and running 
scripts. It’s also the easiest and frequently most effective way to debug scripts. This is 
because the integrated debugger makes it easy to see where you are and what’s going 
on in your scripts. The major debugging features can be found in the Debug menu, 
shown in figure 15.24.
If  you’ve  used  Microsoft  Visual  Studio,  you should  notice  that  the keyboard 
shortcuts are the same as the Visual Studio debugger. A description for each of these 
menu items is shown in table 15.3.
Table 15.3 Menu items in the ISE Debug menu
Menu item
Key
Command equivalent
Description
Step Over
F10
V (Step-Over)
Step over the current function call rather 
than stepping into the function.
Step Into 
F11
S (Step-Into)
Step the script, stepping into functions 
and scripts as they’re encountered.
Step Out
Shift-F11
O (Step-Out)
Execute script lines until the end of the 
current function has been reached.
Run/Continue F5
C (Continue)
If no command is running, the contents 
of the current editor buffer are exe-
cuted. If the interpreter is paused at a 
breakpoint, execution will resume.
Stop 
Debugger
F5
Q (Stop)
Stop debugging session and the script 
being debugged.
Figure 15.24 The debug menu options allow you to set breakpoints and step through your 
script, line by line.
T
HE
P
OWER
S
HELL
V
DEBUGGER
649
Table 15.3 shows the menu item name, the keyboard shortcut if one’s available, and the 
description of the corresponding functionality. What’s a bit unusual for a graphical 
debugger is that the table also lists command-line equivalents to the menu functional-
ity. In fact, there are two types of command equivalents: an actual cmdlet that can be 
called at any time and special single-character shortcut commands that can only be 
used while debugging a script. We’ll walk through an example to see how this all works.
Debugging a script
In this example, you’re debugging a trivial script that just outputs numbers. You want 
to put a breakpoint on line 4, so you move the cursor to line 4 and press 
F
9. The line 
will  be  highlighted  in  red,  indicating  that  there’s  a  breakpoint  set  on that  line. 
Remember that the debugger only works on scripts so you have to save the buffer to a 
file first. Once that’s done, press 
F
5 to begin (if the script had been modified since the 
last save, you’d also be prompted to save it before execution begins). Execution pro-
ceeds, outputting numbers until line 4 in the script is hit and the breakpoint triggers. 
At this point, the line where the breakpoint was hit is highlighted in yellow and the 
command pane displays the debugging prompt, as shown in figure 15.25.
When  the  debugging  prompt  is  displayed,  that  means  the  special  debug 
mode–only commands are now available.
Toggle 
Breakpoint
F9
Set-PSBreakpoint, 
Remove-PSBreakpoint
If there’s no breakpoint on the current 
line, then one will be added. If there’s a 
breakpoint, then it will be removed.
Remove All 
Breakpoints
Ctrl-Shift-F9
Remove-PSBreakpoint
All breakpoints that are set in the cur-
rent session (current tab) will be 
deleted. Breakpoints in other tabs are 
unaffected.
Enable All 
Breakpoints
n/a
Enable-PSBreakpoint
All breakpoints in the current session 
(tab) are enabled. If a breakpoint is cur-
rently enabled, it will remain active. If a 
breakpoint is disabled, it will be 
enabled.
Disable All 
Breakpoints
n/a
Disable-PSBreakpoint All existing breakpoints in the current 
session (tab) are left in place but dis-
abled. They may be re-enabled at a later 
time.
List-
Breakpoints
Ctrl-Shift-L
Get-PSBreakpoint
List all defined breakpoints in the cur-
rent session (tab).
Display Call 
Stack
Ctrl-Shift-D
Get-PSCallStack
After a breakpoint has been hit, this 
command will let you see all the func-
tions or scripts that were called to get 
you to where you are.
Table 15.3 Menu items in the ISE Debug menu (continued)
Menu item
Key
Command equivalent
Description
Documents you may be interested
Documents you may be interested