c# pdf viewer itextsharp : Reorder pages in pdf file software control project winforms web page wpf UWP Windows%20Powershell%20in%20Action%202nd%20Edition58-part1514

550
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
This time it succeeds without any problems. You can run 
Get-Command
to get the list 
of available commands in the session:
[localhost]: PS>Get-Command
CommandType     Name                       Definition 
-----------     ----                       ----------
Function        Exit-PSSession             [CmdletBinding()]... 
Function        Get-Command                [CmdletBinding()]... 
Function        Get-FormatData             [CmdletBinding()]... 
Function        Get-HealthModel            ...
Function        Get-Help                   [CmdletBinding()]... 
Function        Measure-Object             [CmdletBinding()]... 
Function        Out-Default                [CmdletBinding()]... 
Function        Select-Object              [CmdletBinding()]...
Now try running the 
Get-HealthModel
function:
[localhost]: PS>Get-HealthModel
Name                           Value 
----                           -----
FreeSpace                      359284412416 
PageFaults                     215576420 
Date                           2/26/2010 10:05:30 PM 
TopWS                          {System.Diagnostics.Process (svchos... 
TopCPU                         {System.Diagnostics.Process (sqlser...
It works as expected. Now exit the session by calling 
exit
:
[localhost]: PS>exit
The syntax is not supported by this runspace. This might be because 
it is in no-language mode.
+ CategoryInfo          :
+ FullyQualifiedErrorId : ScriptsNotAllowed
You get an error. This error occurs because you’re in 
NoLanguage
mode and 
exit
is a 
keyword. You haven’t seen this before because you haven’t done interactive remoting 
with a constrained session before. The solution to this is to use the 
Exit-PSSession 
function that was defined as part of the standard set of proxy functions:
[localhost]: PS>Exit-PSsession
Now import this session:
PS (6) > $s = New-PSSession localhost -ConfigurationName wpia1 
PS (9) > Import-PSSession $s
ModuleType Name                      ExportedCommands 
---------- ----                      ----------------
Script     tmp_9bed4009-478e-4e91... Get-HealthModel
Reorder pages 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
rearrange pages in pdf reader; how to move pages in a pdf file
Reorder pages 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
how to move pages within a pdf document; switch page order pdf
S
UMMARY
551
The import worked, so you can call 
Get-HealthModel
:
PS (10) > Get-HealthModel
Name                           Value 
----                           -----
Date                           2/26/2010 10:52:36 PM 
TopWS                          {System.Diagnostics.Process (svchos... 
PageFaults                     217681970 
TopCPU                         {System.Diagnostics.Process (sqlser... 
FreeSpace                      360739450880
It works just like a local command. The details of remoting are hidden.
Let’s step back and think about what you’ve accomplished here. With about 40 
lines of script, you’ve defined a secure remote service. And of these 40 lines, most of 
them are a boilerplate preamble. Just paste them at the beginning of the configura-
tion script and then add the additional functions to define the services you want to 
expose.
From the users’ perspective, by using 
Import-PSSession
they’re able to install 
the necessary client software to use this service simply by connecting to the service.
Constrained sessions combined with  implicit remoting results  in an extremely 
flexible  system,  allowing  you  to  create precise  service  boundaries with very little 
server-side code and no client code. Consider how much code would be required to 
create an equivalent service using alternate technologies!
And with this, we’ve come to end of our coverage of the remoting features in 
PowerShell. 
13.3
S
UMMARY
In this chapter, we looked at a PowerShell remoting from the service or application 
creator’s point of view. The goal of the chapter was to show you how to create a cus-
tom service using the remoting capabilities.
To make sure you have the necessary background and context for building this 
service, we explored how PowerShell remoting works. Topics included the following:
• Describing the PowerShell remoting protocol stack, which includes 
HTTP
and 
WSM
an
• Managing 
WSM
an using cmdlets and the 
WSM
an: drive
• Authenticating both the target computer and the incoming user connecting to 
the service
• Understanding various issues related to addressing the target computer
• Ensuring the reliability of your services by managing resource consumption
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# TIFF - Sort TIFF File Pages Order in C#.NET. Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview.
change page order in pdf file; change page order pdf acrobat
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
C# .NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split may choose to only rotate a single page of PDF file or all
how to rearrange pdf pages in preview; move pages in pdf online
552
CHAPTER 13
R
EMOTING
CONFIGURING
APPLICATIONS
AND
SERVICES
Next, you started to build your service. You began by looking at the fan-in and fan-
out service architectures. Then we covered the following:
• Creating custom configurations and remoting endpoints
• Configuring an endpoint with a startup script
• Controlling who has access to the endpoint using 
ACL
s
• Constraining a session by controlling the set of commands visible to users con-
necting to the endpoint
• Controlling the flavor of PowerShell that’s available to the endpoint user
• Using a startup script in a custom configuration that sets up the necessary con-
straints for the application
• Configuring the session so that implicit remoting can be used with the endpoint
PowerShell remoting and the underlying technologies are both broad and deep areas. 
In this chapter and the previous one, we’ve covered most of the features of the technol-
ogies and how they can be applied. The next chapter explores errors and exceptions. 
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
rearrange pdf pages in preview; how to move pages in a pdf
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
reorder pdf pages online; pdf change page order online
553
C
H
A
P T E R   1 4
Errors and exceptions
14.1  Error handling  554
14.2 Dealing with errors that terminate 
execution 569
14.3  Debugging with the host APIs 580
14.4  Capturing session output 593
14.5 PowerShell and the event log 597
14.6 Summary 605
Progress, far from consisting in change, depends on retentiveness. Those who 
cannot remember the past are condemned to repeat it.
—George Santayana, The Life of Reason
It’s always useful to keep in mind that PowerShell isn’t “just” a shell or scripting lan-
guage. Its primary purpose is to be an automation tool and perform critical manage-
ment tasks on a server, such as send software updates, inspect log files, or provision 
user accounts. You need to be sure that either the task is completed properly or the 
reason for failure is appropriately recorded. 
In this chapter, we’ll focus on the latter topic: how PowerShell reports, records, 
and manages error conditions. Handling of error conditions is one of the areas where 
PowerShell shines compared to other scripting tools. The support for diagnostic trac-
ing  and  logging  is  practically  unprecedented  in  traditional  scripting  languages. 
Unfortunately, these features don’t come entirely free—there are costs in terms of 
complexity and execution overhead that aren’t there in other environments. All these
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
delete or remove certain page from PDF document file. C# PDF Page Processing: Sort PDF Pages - online C#.NET tutorial page for how to reorder, sort, reorganize
pdf rearrange pages online; how to reorder pdf pages
Read PDF in Web Image Viewer| Online Tutorials
for image viewing to read, edit, create or write PDF documents from file or stream in Extract images from PDF documents; Add, reorder pages in PDF
how to reorder pages in pdf reader; move pages in a pdf file
554
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
capabilities are very much a part of PowerShell as a management tool; Microsoft set a 
higher bar for PowerShell than has been set for most other language environments.
We’ll begin the chapter by looking at the error processing subsystem. Errors in 
PowerShell aren’t simply error codes, strings, or even exceptions as found in lan-
guages such as C# and 
VB.NET
. They’re rich objects that include just about every-
thing you could think of that might be useful in debugging a problem. 
NOTE
Some people dislike (okay, despise) the use of the word rich in 
this context. But given the wealth of information that PowerShell error 
objects contain, rich really is the right word. 
We’ll examine these 
ErrorRecord
objects in detail, along with how they’re used by 
the various PowerShell mechanisms to manage error conditions. We’ll also look at the 
other mechanisms that are available for solving script execution problems, including 
tracing and script debugging. PowerShell v1 had fairly weak debugging tools. We’ll 
look at how this was addressed by the new features in v2.
14.1
E
RROR
HANDLING
Error handling in PowerShell is very structured. PowerShell errors aren’t simply bits of 
text written to the screen—they’re rich objects that contain a wealth of information 
about where the error occurred and why. There’s one aspect to error handling in 
PowerShell that’s unique: the notion of terminating versus nonterminating errors. This 
aspect aligns with the streaming model that PowerShell uses to process objects. 
Here’s a simple example that will help you understand this concept. Think about 
how removing a list of files from your system should work. You stream this list of files 
to the cmdlet that will delete the files. Imagine that you can’t delete all the files on the 
list for various reasons. Do you want the command to stop processing as soon as it 
hits the first element in the list? The answer is probably, no. You’d like the cmdlet to 
do as much work as it can but capture any errors so that you can look at them later. 
This is the concept of a nonterminating error—the error is recorded and the operation 
continues. On the other hand, there are times when you do want an operation to stop 
on the first error. These are called terminating errors. Sometimes you want an error to 
be terminating in one situation and nonterminating in another, and PowerShell pro-
vides mechanisms that allow you to do this.
Because the architecture supports multiple nonterminating errors being generated 
by a pipeline, it can’t just throw or return an error. Here’s where streaming comes 
into play: nonterminating errors are simply written to the error stream. By default, 
these errors are displayed, but there are a number of other ways of working with 
them. In the next few sections, we’ll look at those mechanisms. But first we need to 
take at look at the error records themselves.
VB.NET TIFF: VB.NET Sample Code to Process & Manage TIFF Page
certain TIFF page, and sort & reorder TIFF pages in Process TIFF Pages Independently in VB.NET Code. powerful & profession imaging controls, PDF document, image
how to move pages around in pdf; reorder pdf pages
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
move pages in pdf file; reorder pages of pdf
E
RROR
HANDLING
555
14.1.1
ErrorRecords and the error stream
As we delve into the topic of error handling, we’ll first take a look at capturing error 
records in a file using redirection, and then you’ll learn how to capture error messages 
in a variable. By capturing these errors instead of just displaying them, you can go 
back at a later time to analyze and hopefully fix what went wrong.
First, let’s review the normal behavior of objects in the pipeline. Output objects 
flow from cmdlet to cmdlet but error records are written directly to the default out-
put processor. By default, this is the 
Out-Default
cmdlet and the error records are 
displayed:
PS (1) > dir nosuchfile
Get-ChildItem : Cannot find path 'C:\files\nosuchfile' because 
it does not exist.
At line:1 char:4 
+ dir  <<<< nosuchfile
These flows are shown in figure 14.1.
In the figure, you see the output objects go from 
A
to 
B
to 
C
and finally to 
Out-
Default
 But  the  error  record  streams  are  all  merged  and  go  directly  to 
Out-
Default
.
When you use the redirection operators discussed in chapter 5, you can change 
flow. For example, you can redirect the error messages to a file:
PS (2) > dir nosuchfile 2> err.txt
A
B
C
Out-Default
PowerShell object flow for
simple pipeline A | B | C
Error records output by A go to input of Out-Default
Error records output by B go to input of Out-Default
Error records output by C go to input of Out-Default
Output of A goes to input of B
Output of B goes to input of C
Output of C goes to input of Out-Default
Figure 14.1 This diagram shows the output object and error record routing; 
then, the simple pipeline 
A | B | C
is run from a PowerShell host process like 
PowerShell.exe
or 
PowerShell_ISE.exe
. Output objects go to the next 
command in the pipeline and error objects go directly to 
Out-Default
.
556
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
This changes the diagram to look like what’s shown in figure 14.2.
But this approach has the downside that the error message is rendered to display-
able text before writing it to the file. When that happens, you lose all the extra infor-
mation in the objects. Take a look at what was saved to the file:
PS (3) > Get-Content err.txt 
Get-ChildItem : Cannot find path 'C:\files\nosuchfile' because 
it does not exist.
At line:1 char:4 
+ dir  <<<< nosuchfile 2> err.txt
The error text is there as it would’ve been displayed on the console, but you’ve lost all 
of the elements of the object that haven’t been displayed. And this lost information 
may be critical to diagnosing the problem. You need a better way to capture this 
information. The first mechanism we’ll look at is capturing the error records by using 
the stream merge operator 
2>&1
, and then assigning the result to a variable.
When you add error stream merging into the picture, the flow of objects changes. 
With stream merging, instead of having all error records going to the default output 
stream, they’re routed into the output stream and the combined set of objects is 
passed to the input of the next command. This flow is shown in figure 14.3.
Let’s see how this works. First use the stream merge operator to capture the error 
stream in a variable by using assignment:
PS (4) > $err = dir nosuchfile 2>&1
A
B
C
Out-Default
PowerShell object flow for
pipeline
A 2> foo.txt | B | C
Error records output by A go to input of Out-File
Error records output by B go to input of Out-Default
Error records output by C go to input of Out-Default
Output of A goes to input of B
Output of B goes to input of C
Output of C goes to input of Out-Default
Out-File err.txt
Figure 14.2 Revised pipeline including the use of redirection operators
E
RROR
HANDLING
557
Now use 
Get-Member
to display the properties on the object. Use the 
-Type
parame-
ter on 
Get-Member
to filter the display and only show the properties:
PS (5) > $err | Get-Member -Type property
TypeName: System.Management.Automation.ErrorRecord
Name                  MemberType Definition 
----                  ---------- ----------
CategoryInfo          Property   System.Management.Automation... 
ErrorDetails          Property   System.Management.Automation... 
Exception             Property   System.Exception Exception {... 
FullyQualifiedErrorId Property   System.String FullyQualified... 
InvocationInfo        Property   System.Management.Automation... 
TargetObject          Property   System.Object TargetObject {...
Although this shows you all the properties and their definitions, some of the property 
names are a little tricky to figure out, so further explanation is in order. Table 14.1 
lists all the properties, their types, and a description of each property.
Table 14.1 ErrorRecord properties and their descriptions
Property name
Property type
Description
CategoryInfo
ErrorCategoryInfo This string breaks errors into a number of 
broad categories.
ErrorDetails
ErrorDetails
This may be null. If present, ErrorDetails
can specify additional information, most 
importantly ErrorDetails.Message, 
which (if present) is a more exact descrip-
tion and should be displayed instead of 
Exception.Message.
A
B
C
Out-Default
PowerShell object flow for
pipeline 
A 2>&1 | B | C
Error records output by A go to input of B
Error records output by B go to input of Out-Default
Error records output by C go to input of Out-Default
Output of A goes to input of B
Output of B goes to input of C
Output of C goes to input of Out-Default
Figure 14.3 Revised pipeline 
including the addition of error 
stream merging
558
CHAPTER 14
E
RRORS
AND
EXCEPTIONS
You can look at the values of an error record’s properties by piping the error object 
into 
Format-List
. To see all the properties, you must specify 
–Property  *
along 
with 
–Force
. This command tells the formatting subsystem to skip the default pre-
sentation and show all properties. The result looks like this:
PS (10) > $err | Format-List –Property * -Force
Exception             : System.Management.Automation.ItemNotFoun
dException: Cannot find path 'C:\files\n
osuchfile' because it does not exist.
at System.Management.Automation.Sessi
onStateInternal.GetChildItems(String pat
h, Boolean recurse, CmdletProviderContex
t context)
at System.Management.Automation.Child
ItemCmdletProviderIntrinsics.Get(String
path, Boolean recurse, CmdletProviderCon
text context)
at Microsoft.PowerShell.Commands.GetC
hildItemCommand.ProcessRecord()
TargetObject          : C:\files\nosuchfile 
CategoryInfo          : ObjectNotFound: (C:\files\nosuchfile:Str
ing) [Get-ChildItem], ItemNotFoundExcept
ion 
FullyQualifiedErrorId : PathNotFound,Microsoft.PowerShell.Comman
ds.GetChildItemCommand 
ErrorDetails          : 
InvocationInfo        : System.Management.Automation.InvocationI
Nfo
In this output, you can see the exception that caused the error was 
ItemNotFound-
Exception
. The 
TargetObject
property contains the full path the cmdlet used to
Exception
System.Exception
This is the underlying .NET exception corre-
sponding to the error that occurred.
FullyQualifiedErrorId System.String
This identifies the error condition more spe-
cifically than either the ErrorCategory or 
the Exception. Use FullyQualified-
ErrorId to filter highly specific error condi-
tions. Note that this is a nonlocalized field, 
so performing string matches against it will 
continue to work regardless of language set-
tings.
InvocationInfo
InvocationInfo
This is an object that contains information 
about where the error occurred—typically 
the script name and line number.
TargetObject
System.Object
This is the object that was being operated 
on when the error occurred. It may be null, 
as not all errors will set this field.
Table 14.1 ErrorRecord properties and their descriptions (continued)
Property name
Property type
Description
E
RROR
HANDLING
559
locate the item. This overall error is placed in the broader category of 
ObjectNot-
Found
. There are no additional error details for this object.
Let’s take a closer look at the 
InvocationInfo
property. This member provides 
information about where the error occurred. Here’s what it looks like:
PS (6) > $err.InvocationInfo
MyCommand        : Get-ChildItem 
ScriptLineNumber : 1 
OffsetInLine     : 11 
ScriptName       : 
Line             : $err = dir nosuchfile 2>&1 
PositionMessage  :
At line:1 char:11
+ $err = dir  <<<< nosuchfile 2>&1 
InvocationName   : dir 
PipelineLength   : 1 
PipelinePosition : 1
Because you entered this command on the command line, the script name is empty 
and the script line is 1. 
OffsetInLine
is the offset in the script line where the error 
occurred. Other information is also available, such as the number of commands in 
the pipeline that caused an error, as well as the index of this command in the pipeline. 
This message also includes the line of script text where the error occurred. Finally, 
there’s the 
PositionMessage
property. This property takes all the other information 
and formats it into what you see in PowerShell errors.
Extracting all of the detailed information from an error record is a fairly common 
occurrence when debugging scripts, so it’s worth writing a small helper function to 
make it easier. Listing 14.1 shows a function that will dump out all the properties of 
an error object and then iterate through any 
InnerException
properties on the error 
record exception to show all the underlying errors that occurred.
function Show-ErrorDetails 
{
param(
$ErrorRecord = $Error[0]  
)
$ErrorRecord | Format-List * -Force     
$ErrorRecord.InvocationInfo | Format-List *   
$Exception = $ErrorRecord.Exception  
for ($depth = 0; $Exception -ne $null; $depth++)
{   "$depth" * 80                           
$Exception |Format-List -Force *   
$Exception = $Exception.InnerException
}
This function takes a single parameter, which holds the error record to display. By 
default, it shows the most recent error recorded in 
$error
. It begins by showing all the
Listing 14.1    The Show-ErrorDetails function
Show depth 
of nested 
exception
b
Show exception properties
c
Link to nest 
exceptions
d
Documents you may be interested
Documents you may be interested