c# pdf viewer itextsharp : Reorder pages in pdf control Library system azure asp.net winforms console Windows%20Powershell%20in%20Action%202nd%20Edition68-part1525

650
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
NOTE
Earlier we said that because of the way debugging works in 
PowerShell,  you  don’t  need  a  new  language.  This  is  definitely 
true—but you do need some convenience aliases; otherwise, things are 
too verbose to use easily. That’s what you’re seeing here.
For example, to step the next line, you could either type the command 
s
or 
Step-Over 
or use the Debug > Step Over menu item. Regardless of how you enter the command, 
the line where you’d hit the breakpoint is executed and then breaks at the next line in 
the script. This line is now highlighted in yellow. The previous line is highlighted in red 
because it has an actual breakpoint on it, as you can see in figure 15.26.
Command prompt changes to indicate debugging
mode; special debugger commands now active
Breakpoint on line
4 hit: relevant line 
highlighted in
editor pane
Output pane
shows output of 
script so far 
(numbers 1, 2, 3)
and message 
indicating
breakpoint has 
been hit
Editor 
pane
Output 
pane
Command 
pane
Figure 15.25 The command pane changes once a breakpoint has been hit. The prompt is pre-
fixed with 
>>
to indicate that you’re debugging and the debugger commands are enabled.
When Step-Over 
command issued,
highlight moves to 
next statement
Output pane shows
updated output, including 
4 from line with
breakpoint, and displays
message indicating
breakpoint was hit
Editor 
pane
Output 
pane
Command 
pane
Figure 15.26 The command pane changes once a breakpoint has been hit. The prompt is pre-
fixed with 
>>
to indicate that you’re debugging and the debugger commands are enabled.
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
pdf change page order online; change page order in pdf reader
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
rearrange pdf pages in preview; how to reorder pages in pdf file
T
HE
P
OWER
S
HELL
V
DEBUGGER
651
The full set of debugger shortcut commands is shown in table 15.4.
Executing other commands in debug mode
If you look at the various tables so far, there’s clearly something missing. Knowing 
where you are is great, but you need more for effective debugging. You need to be 
able to examine variables, change their values, look at functions, and so on. The solu-
tion turns out to be simple: for the most part, you can just use the same cmdlets 
you’ve used all along. To see a variable, use 
Get-Variable
; to change a variable, use 
assignment or the 
Set-Variable
command. Debug mode just adds some new com-
mands to the environment; all of the existing commands are still available so you have 
the full power of PowerShell available in this environment.
Table 15.4 The special commands that are available in debug mode
Command
Full name
Description
V
Step-Over
Step over the current function call rather than stepping 
into the function.
S
Step-Into
Step through the script, stepping into functions and 
scripts as they’re encountered.
O
Step-Out
Execute script lines until the end of the current function 
has been reached.
C
Continue
If no command is running, the contents of the current 
editor buffer are executed. If the interpreter is paused at 
a breakpoint, execution will resume.
L [<m> [<n>]]
List
List the portion of the script around the line where 
you’re currently stopped. By default, the current line is 
displayed, preceded by the 5 previous lines, and then 
followed by the 10 subsequent lines. To continue listing 
the script, press the Enter key. The List command can 
be optionally followed by a number specifying the 
number of lines to display before and after the current 
line. If two numbers are specified, the first number is 
the number of preceding lines and the second is the 
number of following lines.
Q
Stop
Stop execution, which also stops the debugger.
K
Get-PSCallStack
Display up to the current execution point. This com-
mand isn’t specific to debug mode and may be used 
anywhere.
<Enter>
Pressing the Enter key on an empty line repeats the last 
S, V, or L command entered. This makes it easy to con-
tinue stepping or to list the script.
?, h
Display all the special debugger commands in the 
output pane.
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.
reorder pages pdf; how to reorder pages in pdf online
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
how to change page order in pdf document; how to rearrange pdf pages
652
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
Hovering over variables to see their values
Some users don’t want to type a command to look at variables, so like Visual Studio, 
the 
ISE
allows you to hover the mouse pointer over a variable to see its value. Simply 
place the mouse pointer over the variable you want to see in the editor and its value 
will be displayed. Figure 15.27 shows what this looks like.
Note that there is one caveat: if the script isn’t running, then the variable won’t 
have a value. Or, more confusingly, if there’s another variable in an active scope with 
the same name, you’ll see that value rather than the one you were expecting. This is 
one of the tricky aspects of dynamically scoped environments.
NOTE
By now you may have noticed that you aren’t passing parame-
ters to the scripts you’re running. In fact, when you run a script by 
pressing F5 or using the menu, you have no way to specify parameters 
to the script you’re about to run. The workaround is to run the script 
from the 
ISE
command line where you can specify parameters.
Because PowerShell is a shell, you also have to be able to debug directly from the 
command line, which is our next topic.
15.6
C
OMMAND
-
LINE
DEBUGGING
Given the nature of the PowerShell environment, you need to support debugging in a 
variety of environments. The most effective way to do this is to enable debugging 
scripts from the command line. This makes it possible to use the debugger from the 
console host as well. As always, these debugging features are surfaced through a set of 
cmdlets. The cmdlets are listed in table 15.5.
Figure 15.27 When the mouse pointer is placed over the variable, the variable’s 
value is displayed in a tooltip.
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 pdf pages reader; how to reorder pdf pages
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
move pages in pdf acrobat; reverse page order pdf online
C
OMMAND
-
LINE
DEBUGGING
653
Command-line debugging is also important for another reason: there are many more 
things you can do using these cmdlets, including writing scripts to debug scripts. In 
other words, all of the features you’ve seen in the 
GUI
debugger are available from the 
command line, but not all of the command-line features are available from the 
GUI
.
NOTE
There is, of course, no deep technical reason why this is so. 
Using the 
ISE
object model, it’s possible to backfill many of the miss-
ing features.
In fact, the 
GUI
debugger only surfaces a portion of the functionality of what can be 
done with the PowerShell debugger. In the next few sections, we’ll dig into these 
capabilities.
15.6.1
Working with breakpoint objects
Let’s begin  our  discussion  by taking a  detailed  look how  breakpoints  are  imple-
mented. So far you’ve seen a fairly conventional debugger experience, but the intro-
spective nature of PowerShell  allows you  to do  much  more when  working with 
breakpoints. As with most everything else, breakpoints in PowerShell are objects that 
you can script against. As always, you’ll use 
Get-Member
to examine these objects:
PS (STA) (42) > Get-PSBreakPoint | Get-Member
TypeName: System.Management.Automation.LineBreakpoint
Name        MemberType Definition 
----        ---------- ----------
Equals      Method     bool Equals(System.Object obj)
GetHashCode Method     int GetHashCode()
GetType     Method     type GetType()
ToString    Method     string ToString()
Action      Property   System.Management.Automation.ScriptBlock Action 
{get;}
Column      Property   System.Int32 Column {get;} 
Enabled     Property   System.Boolean Enabled {get;} 
HitCount    Property   System.Int32 HitCount {get;} 
Id          Property   System.Int32 Id {get;}
Line        Property   System.Int32 Line {get;} 
Script      Property   System.String Script {get;}
Table 15.5 The PowerShell debugger cmdlets
Cmdlet
Description
Get-PSCallStack
Gets the current call stack
Enable-PSBreakPoint
Enables an existing breakpoint
Disable-PSBreakPoint
Disables a breakpoint without removing it
Set-PSBreakPoint
Sets a breakpoint
Get-PSBreakPoint
Gets the list of breakpoints
Remove-PSBreakPoint
Removes an existing breakpoint
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
pdf reorder pages online; rearrange pdf pages in reader
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.
pdf change page order; move pages in pdf online
654
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
In this output, you see some familiar bits of information: the breakpoint 
ID
and the 
line and script where it applies. Much more interesting are things like 
HitCount
and 
especially the 
Action
property.
The 
HitCount
property records the number of times a breakpoint has been 
hit—not terribly interesting but useful sometimes. The really interesting property is 
Action
 which
holds instances  of  our  old  friend the  scriptblock.  By  specifying 
actions in scriptblocks, breakpoints can do much more than simply interrupting exe-
cution when the breakpoint is hit. Using scriptblocks allows you to perform arbitrary 
actions controlling when or even if the breakpoint fires. Let’s see how this works with 
a simple test script:
PS (1) > Get-Content testscript2.ps1 
"Starting" 
$sum = 0 
foreach ($i in 1..10) 
{
$sum += $i 
}
"The sum is $sum"
This script loops over the numbers from 1 to 10, summing them up and then print-
ing the result. Now define a breakpoint for this script using the 
Set-PSBreakPoint 
command:
PS (2) > $firstBP = Set-PSBreakpoint -Script testscript2.ps1 -Line 5 ` 
>> -Action { 
>>     if ($i -gt 3 -and $i -lt 7) 
>>     { 
>>         Write-Host ">>> DEBUG ACTION: i = $i, sum = $sum" 
>>     } 
>> } 
>>
This command specifies that a scriptblock will be executed every time you hit line 5 
in the test script. In the body of the scriptblock, you’re checking to see if the value of 
$i
is greater than 3 and less than 7. If so, you’ll display a message. You have to use 
Write-Host
to display this message because the results of the scriptblock aren’t dis-
played.  The 
Set-PSBreakpoint
command returns an instance of a breakpoint 
object. Let’s display it as a list so you can see its members:
PS (3) > $firstBP  | Format-List
Id       : 1
Script   : C:\wpia_v2\text\chapter15\code\testscript2.ps1 
Line     : 5 
Column   : 0 
Enabled  : True 
HitCount : 0 
Action   :
if ($i -gt 3 -and $i -lt 7)
{
.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.
pdf rearrange pages online; move pages in pdf file
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
pdf rearrange pages; pdf reverse page order online
C
OMMAND
-
LINE
DEBUGGING
655
Write-Host ">>> DEBUG ACTION: i = $i, sum = $sum"
}
This code shows the full path to the script and the line in the script that will trigger 
the action as well as the action itself. Run the test script to see how it works:
PS (4) > ./testscript2.ps1
Starting 
>>> DEBUG ACTION: i = 4, sum = 6 
>>> DEBUG ACTION: i = 5, sum = 10 
>>> DEBUG ACTION: i = 6, sum = 15 
The sum is 55
The output shows the value of 
$i
and 
$sum
as long as 
$i
is between 3 and 7 as 
intended.
Before we move on to the next example, remove all of the breakpoints so they 
don’t confuse the results in the example:
PS (5) > Get-PSBreakpoint | Remove-PSBreakpoint
This time, instead of just displaying a message, you’re going to use the 
break
key-
word to break the script under specific conditions. Here’s the command to define the 
new breakpoint:
PS (6) > $firstBP = Set-PSBreakpoint -Script testscript2.ps1 -Line 5 -
Action { 
>>     if ($i -eq 4) 
>>     { 
>>         Write-Host ">>> DEBUG ACTION: i = $i, sum = $sum" 
>>         break 
>>     } 
>> } 
>>
For this breakpoint, you’ll only fire the action on line 5 of the test script. In the 
scriptblock body, you display the message as before and then call 
break
, which will 
break the execution of the script:
PS (7) > ./testscript2.ps1
Starting 
>>> DEBUG ACTION: i = 4, sum = 6 
Entering debug mode. Use h or ? for help.
Hit Line breakpoint on 
'C:\wpia_v2\text\chapter15\code\testscript2.ps1:5'
testscript2.ps1:5       $sum += $i
As was the case in the graphical debugger, you have the same set of options available 
at the break prompt:
PS (8) > ?
s, stepInto     Single step (step into functions, scripts, etc.)
v, stepOver     Step to next statement (step over functions, scri
656
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
pts, etc.)
o, stepOut      Step out of the current function, script, etc.
c, continue     Continue execution
q, quit         Stop execution and exit the debugger
k, Get-PSCallStack Display call stack
l, list   List source code for the current script.
Use "list" to start from the current line, "list <m>"
to start from line <m>, and "list <m> <n>" to list <n>
lines starting from line <m>
<enter>   Repeat last command if it was stepInto, stepOver or list
?, h                Displays this help message
For instructions about how to customize your debugger prompt, type 
"help about_prompt".
You’ll use the 
c
command to continue execution:
PS (9) > c
The sum is 55
The completed script displays the sum. And, as before, clean up the breakpoint:
PS (10) > Get-PSBreakpoint | Remove-PSBreakpoint
Now, let’s move on to the next example.
15.6.2
Setting breakpoints on commands
The most common scenario using the debugger involves setting breakpoints on lines 
in a file, but it’s also possible to break on a specific command. Define a simple function
PS (15) > function hello { "Hello world!" }
and set a breakpoint on that function:
PS (16) > Set-PSBreakpoint -Command hello
ID Script         Line Command        Variable       Action
-- ------         ---- -------        --------       ------
                    hello
This time you won’t associate an action and you’ll allow the default behavior—caus-
ing a break in execution—to occur. Execute the function:
PS (17) > hello
Entering debug mode. Use h or ? for help.
Hit Command breakpoint on 'hello'
hello
When the command is run, you immediately hit the breakpoint. Enter 
c
and allow 
the function to complete:
PS (18) > c
Hello world!
C
OMMAND
-
LINE
DEBUGGING
657
Among other things, the ability to set breakpoints on commands as opposed to spe-
cific lines in a script allows you to debug interactively entered functions. Now let’s 
move on to the final example in this section: setting breakpoints on variables.
15.6.3
Setting breakpoints on variable assignment
In the previous examples, the breakpoints were triggered when execution reached a 
certain line in the script or you entered a command. You can also cause a break when 
variables are read or written. In the following command, you’ll specify an action to 
take when the 
$sum
variable is written:
PS (12) > $thirdBP = Set-PSBreakpoint -Variable sum -Mode Write ` 
>> -Action { 
>>      if ($sum -gt 10) 
>>      { 
>>          Write-Host ">>> VARIABLE sum was set to $sum" 
>>      } 
>> } 
>>
For this breakpoint, you’re using 
-Mode Write
to specify that the breakpoint should 
only trigger when the variable is written. In practice, this could have been omitted 
because 
Write
is the default mode (the other modes are 
Read
and 
ReadWrite
). Then 
in the action scriptblock, you’ll use 
Write-Host
as before to display the value of 
$sum
, but only when it’s greater than 10. Let’s see what this breakpoint looks like:
PS (13) > $ thirdBP | Format-List
Id         : 3
Variable   : sum 
AccessMode : Write 
Enabled    : True 
HitCount   : 0 
Action     :
if ($sum -gt 10)
{
Write-Host ">>> VARIABLE sum was set to $sum"
}
You see the line, variable, and access mode that will trigger the action and the script-
block to execute when triggered. Run the test script:
PS (14) > ./testscript2.ps1
Starting 
>>> VARIABLE sum was set to 15 
>>> VARIABLE sum was set to 21 
>>> VARIABLE sum was set to 28 
>>> VARIABLE sum was set to 36 
>>> VARIABLE sum was set to 45 
The sum is 55
658
CHAPTER 15
T
HE
P
OWER
S
HELL
ISE 
AND
DEBUGGER
You see the output messages from the action scriptblock. One of the nice things is 
that a variable-based breakpoint isn’t tied to a specific line number in the script so it 
will continue to work even when you edit the script.
Although these examples are by no means exhaustive, they give you a sense of the 
capabilities of the PowerShell command-line debugger. You’re able to do much more 
sophisticated debugging from the command line. But even for the command line, 
there are a number of limitations to the debugging capabilities. We’ll look at these 
limitations in the final section in this chapter.
15.6.4
Debugger limitations and issues
The PowerShell debugger, though powerful, does suffer from a number of limita-
tions. Probably the biggest limitation is that remote debugging isn’t currently sup-
ported. Even in an interactive remoting session, the debugger won’t work:
[localhost]: PS (1) > Set-PSBreakpoint -Script ` 
>> testfile2.ps1 -Line 5 
Debugging is not supported on remote sessions.
+ CategoryInfo          :
+ FullyQualifiedErrorId : SetPSBreakpoint:RemoteDebuggerNotSuppo
rted,Microsoft.PowerShell.Commands.SetPSBreakpointCommand
This is, in part, because the remote host environment doesn’t support the required 
EnterNestedPrompt()
function you saw earlier:
[localhost]: PS (2) > $host.EnterNestedPrompt()
Exception calling "EnterNestedPrompt" with "0" argument(s): "Remote 
host method get_Runspace is not implemented."
At line:1 char:24 
+ $host.EnterNestedPrompt <<<< ()
+ CategoryInfo          : NotSpecified: (:) [], MethodInvocation
Exception
+ FullyQualifiedErrorId : DotNetMethodException
A corollary to this is that you can’t attach to a running PowerShell instance to debug 
it. In fact, of all of the debugging tools we’ve looked at, the only one available in the 
remoting environment is tracing using the 
Set-PSDebug
command.
There are some other issues to be aware of as well. The dynamic nature of the 
PowerShell language means that code can be created at any time and you aren’t always 
able to set breakpoints on this code. This is where the techniques you saw earlier in the 
chapter can help. The example breakpoint function can be inserted into dynamic or 
anonymous code, allowing you to effectively set a breakpoint in that code.
Finally, because variables are never declared, it’s not possible to specify an instance 
of a variable via its declaration; you can only select the target variable by name. Scop-
ing a breakpoint to a particular file or command helps with correctly targeting the 
desired variable.
S
UMMARY
659
In practice, the only one of these limitations that’s likely to impact day-to-day 
scripting is the limitation on remote debugging. In those scenarios, if tracing is insuf-
ficient you’ll need to replicate the remote environment locally to do the debugging.
At this point, we’ll wrap up our discussion of the PowerShell debugging capabili-
ties. We started with tracing and simulating breakpoints, then looked at using the 
integrated debugger in the 
ISE
, and finally spent some time looking at how to use the 
command-line debugger. With these simple examples, we’ve only scratched the sur-
face of what can be done with the debugger. The ability to associate actions with 
breakpoints allows you to create arbitrarily sophisticated criteria for triggering break-
points, including having breakpoints create other breakpoints dynamically. At the 
same time, the nature of PowerShell as a highly dynamic environment can make 
debugging some scenarios quite challenging. As always, with PowerShell debugging, 
the most effective way to learn it is to use and experiment with its capabilities.
This completes our coverage of the PowerShell 
ISE
and debugger. We said at the 
beginning of the chapter that this is a very large topic, so congratulations for making 
it all the way through. This also completes our coverage of the PowerShell features. In 
the next chapter, we switch from looking at PowerShell on a feature-by-feature basis 
and take a holistic approach to applying the things that you’ve learned.
15.7
S
UMMARY
This chapter introduced the PowerShell 
ISE
and debugger. We began the chapter by 
covering the basic operations and features of the 
ISE
:
• Controlling and customizing 
ISE
pane layout
• Running scripts with F5 and portions of scripts with F8
• Working with the editor
• Working with multiple tabs, including remote PowerShell tabs
Next we looked at how to extend the 
ISE
environment using the 
ISE
object model. 
We started with an overview of the types in the object model, then looked at working 
with the following:
• Adding and renaming tabs
• Invoking commands in another tab
• Accessing the contents of the output and editor panes
Then we explored adding custom menus to the environment. You followed examples 
where you added menu items to insert snippets of code into the editor buffer and a 
command to run a syntax check on the current editor buffer.
In the second part of the chapter, we looked at the PowerShell debugger. We 
described the  tracing and  stepping features that were  carried  over  from  the first
Documents you may be interested
Documents you may be interested