c# pdf viewer itextsharp : How to change page order in pdf acrobat software SDK dll windows winforms web page web forms Windows%20Powershell%20in%20Action%202nd%20Edition74-part1532

710
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
Because  the 
XL
inq  library  isn’t  automatically  loaded  when  PowerShell  starts, 
you’ll use 
Add-Type
to add the necessary assemblies:
PS (17) > Add-Type -AssemblyName System.Core 
PS (18) > Add-Type -AssemblyName System.Xml.Linq
You’re ready to try out a query. Let’s re-implement the previous example where you 
calculated  the  value  of  the  inventory  using 
XL
inq.  First,  you  have  to  create  an 
instance of an 
XDocument
document, which is the class that 
XL
inq uses to represent a 
document instead of the 
XmlDocument
, which is what the built-in 
XML
support uses. 
Even so, as is the case with 
[xml]
, you can just cast your inventory string into an 
XDocument
instance:
PS (19) > $xldoc = [System.Xml.Linq.XDocument] $inventory
Now that you have the document, you can run the query. As before, you need to 
retrieve all of the book elements that are descendants of the root node. To do so, all 
you have to do is call the 
Descendants()
method on the document and pass in the 
name of the elements you want to retrieve. Then you have to extract the properties 
from the nodes that are returned. 
XL
inq isn’t natively supported in PowerShell, so 
you can’t use the simple property references as you did in the 
XP
ath case. Instead, 
you have to call the 
Element()
method on the node, passing in the name of the ele-
ment to retrieve:
PS (20) > $xldoc.Descendants("book") | 
>> foreach { 
>>     [double] $_.Element("price").value * 
>>         $_.Element("stock").value } | 
>> Measure-Object -Sum | foreach { $_sum } 
>> 
356.81
Once you have the elements, the rest is basically the same: you cast the element strings 
into numbers, multiply them, and then use 
Measure-Object
to sum the results.
We’ve looked at how to use the 
XML
facilities in the .
NET F
ramework to create 
and process 
XML
documents. As the 
XML
format is used more frequently in the com-
puter industry, these features will become critical. We’ve only scratched the surface of 
what’s available in the .
NET
Framework. We’ve covered some of the 
XML
classes and 
a little of the 
XP
ath query language. We haven’t discussed how to use the Extensible 
Stylesheet Language Transformations 
(XSLT)
language,
XML schemas, or any of a num-
ber of
XML
-related standards and tools. That said, most of these tools are directly 
available from within the PowerShell environment. The interactive nature  of the 
PowerShell environment makes it an ideal place to explore, experiment, and learn 
more about 
XML
. In the next section, we’ll show you how to generate 
XML
docu-
ments from PowerShell objects automatically by using the built-in cmdlets.
How to change page order in pdf acrobat - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
rearrange pdf pages reader; rearrange pdf pages in reader
How to change page order in pdf acrobat - 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; reorder pages pdf
XML 
STRUCTURED
TEXT
PROCESSING
711
16.4.7
Rendering objects as XML
Up to this point, you’ve been working with 
XML
as objects. Now you’re going to 
switch it around and render objects into 
XML
using cmdlets. PowerShell provides two 
cmdlets for rendering objects  as 
XML
 each with  slightly  different purposes. The 
ConvertTo-Xml
renders objects with relatively simple but verbose format. This cmd-
let is useful for interoperating between PowerShell and other environments. Conver-
sions using 
Export-Clixml
are much more complex but also more compact and are 
intended for efficiently passing data between instances of PowerShell. We’ll start with 
the simpler of the two: 
ConvertTo-Xml
.
The ConvertTo-Xml cmdlet
The 
ConvertTo-Xml
cmdlet does a fairly simple and direct rendering of PowerShell 
objects into 
XML
. Its primary value is to facilitate interoperability between Power-
Shell and other environments (including non-Windows environments). Because the 
encoding used is simple, it can be easily consumed by other applications. The signa-
ture for this command is shown in figure 16.4.
As you see in the figure, the cmdlet takes an object as an argument or (more 
commonly) as pipeline input and generates an 
XML
document from it. Let’s use it to 
produce 
XML
from a list of Windows services. You’ll get the list using the 
Get-
Service
cmdlet, but you’ll limit the number of services you’ll work with to three 
for brevity’s sake:
PS (1) > (Get-Service)[0..2]
Status   Name               DisplayName 
------   ----               -----------
Stopped  AdtAgent           Operations Manager Audit Forwarding... 
Running  AeLookupSvc        Application Experience 
Stopped  ALG                Application Layer Gateway Service
ConvertTo-XML 
[-InputObject] <psobject>
[-As <string>] 
[-Depth <int>]
[-NoTypeInformation] 
Cmdlet name
Depth of subproperties
to include in output
document; default is 2
Output document won’t
include information about 
type of object converted
Object to convert to
XML document
How output will be written: 
String, Stream, or
Document (default)
Figure 16.4 The 
ConvertTo-Xml
cmdlet parameters. This cmdlet facilitates 
interoperation between PowerShell and other applications by using a simple 
XML encoding.
.NET PDF Document Viewing, Annotation, Conversion & Processing
Convert image files to PDF. File & Page Process. Re-order, rotate PDF pages. PDF Read. Print. Support for all the print modes in Acrobat PDF.
reorder pages in pdf preview; how to move pages around in pdf
VB.NET PDF: How to Create Watermark on PDF Document within
create a watermark to PDF file in order to help or image (such as business's logo) on any desired PDF page. And with our PDF Watermark Creator, users need no
how to move pdf pages around; reorder pages of pdf
712
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
In this output, you see the normal PowerShell presentation for 
ServiceController 
objects. Convert them into 
XML
:
PS (2) > $doc = (Get-Service)[0..2] | ConvertTo-Xml
Look at the resulting 
XML
document:
PS (3) > $doc
xml                                Objects 
---                                -------
version="1.0"                      Objects
The  collection of objects  is rendered into an 
XML
document with the top node 
Object
, which, in turn, contains a collection of 
Object
elements as shown:
PS (4) > $doc.Objects.Object
Type                               Property 
----                               --------
System.ServiceProcess.ServiceCo... {Name, RequiredServices, CanPau... 
System.ServiceProcess.ServiceCo... {Name, RequiredServices, CanPau... 
System.ServiceProcess.ServiceCo... {Name, RequiredServices, CanPau...
Here you see that each 
Object
element has the type and properties of the source object 
included in the output document. But this representation doesn’t show the document 
format effectively, so use the 
-As
parameter to display the document as a single string:
PS (5) > $services[0] | ConvertTo-Xml -As string 
<?xml version="1.0"?> 
<Objects>
<Object Type="System.ServiceProcess.ServiceController">
<Property Name="Name" Type="System.String">AdtAgent</Property>
<Property Name="RequiredServices"
Type="System.ServiceProcess.ServiceController[]">
<Property Type="System.ServiceProcess.ServiceController">
System.ServiceProcess.ServiceController</Property>
<Property Type="System.ServiceProcess.ServiceController">
System.ServiceProcess.ServiceController</Property>
</Property>
<Property Name="CanPauseAndContinue" Type="System.Boolean">
False</Property>
<Property Name="CanShutdown" Type="System.Boolean">
False</Property>
<Property Name="CanStop" Type="System.Boolean">False</Property>
<Property Name="DisplayName" Type="System.String">
Operations Manager Audit Forwarding Service</Property>
<Property Name="DependentServices"
Type="System.ServiceProcess.ServiceController[]" />
<Property Name="MachineName" Type="System.String">.</Property>
<Property Name="ServiceName" Type="System.String">
AdtAgent</Property>
<Property Name="ServicesDependedOn"
Type="System.ServiceProcess.ServiceController[]">
<Property Type="System.ServiceProcess.ServiceController">
GIF to PDF Converter | Convert GIF to PDF, Convert PDF to GIF
as easy as printing; Support both single-page and batch Drop image to process GIF to PDF image conversion; Provide filter option to change brightness, color and
how to rearrange pages in a pdf file; how to change page order in pdf acrobat
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
It can be used standalone. JPEG to PDF Converter is able to convert image files to PDF directly without the software Adobe Acrobat Reader for conversion.
rearrange pdf pages in preview; how to reverse page order in pdf
XML 
STRUCTURED
TEXT
PROCESSING
713
System.ServiceProcess.ServiceController</Property>
<Property Type="System.ServiceProcess.ServiceController">
System.ServiceProcess.ServiceController</Property>
</Property>
<Property Name="ServiceHandle"
Type="System.Runtime.InteropServices.SafeHandle" />
<Property Name="Status"
Type="System.ServiceProcess.ServiceControllerStatus">
Stopped</Property>
<Property Name="ServiceType"
Type="System.ServiceProcess.ServiceType">
Win32OwnProcess</Property>
<Property Name="Site" Type="System.ComponentModel.ISite" />
<Property Name="Container" Type="System.ComponentModel.IContainer" /> 
</Object>
Now the structure of the saved data is much clearer. The type name of the original 
object is included as an attribute on the 
Object
tab. The child elements of 
Object 
are a collection of 
Property
objects with the property name and type as attributes 
and the value as the element content.
One thing we didn’t mention yet was the “serialization” depth. The default depth 
is 2. You see this in the 
RequiredServices
property, whose content is two addi-
tional nested properties. You can override the default depth using the 
-Depth
param-
eter on the cmdlet.
NOTE
You might be tempted to set the depth to a larger value to pre-
serve more information, but be aware that the size of the document can 
explode with deep nesting. For example, saving the process table with 
the default depth of 2 produces a 700 
KB
file, which is already quite 
large. Increasing the depth to 3 explodes the file to 7 
MB
—a tenfold 
increase in size!
The  other  parameter  on  the  cmdlet  that  we  haven’t  talked  about  is 
-NoType-
Information
. When you specify this parameter, no type information is included in 
the generated document. Let’s see how the resulting document looks without the type 
information by rerunning the example with 
-NoTypeInformation
:
PS (6) > $services[0] | ConvertTo-Xml -NoTypeInformation -As string 
<?xml version="1.0"?> 
<Objects>
<Object>
<Property Name="Name">AdtAgent</Property>
<Property Name="RequiredServices">
<Property>System.ServiceProcess.ServiceController</Property>
<Property>System.ServiceProcess.ServiceController</Property>
</Property>
<Property Name="CanPauseAndContinue">False</Property>
<Property Name="CanShutdown">False</Property>
<Property Name="CanStop">False</Property>
<Property Name="DisplayName">Operations Manager Audit Forwarding
PDF to WORD Converter | Convert PDF to Word, Convert Word to PDF
PDF to Word Converter has accurate output, and PDF to Word Converter doesn't need the support of Adobe Acrobat & Microsoft Word.
how to reorder pages in pdf preview; move pdf pages online
TIFF to PDF Converter | Convert TIFF to PDF, Convert PDF to TIFF
doesn't require other third-party such as Adobe Acrobat. a few clicks; Ability to convert PDF documents to and upgrade; Easy to convert multi-page PDF files to
move pages in a pdf file; how to reorder pages in pdf
714
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
Service</Property>
<Property Name="DependentServices" />
<Property Name="MachineName">.</Property>
<Property Name="ServiceName">AdtAgent</Property>
<Property Name="ServicesDependedOn">
<Property>System.ServiceProcess.ServiceController</Property>
<Property>System.ServiceProcess.ServiceController</Property>
</Property>
<Property Name="ServiceHandle" />
<Property Name="Status">Stopped</Property>
<Property Name="ServiceType">Win32OwnProcess</Property>
<Property Name="Site" />
<Property Name="Container" />
</Object> 
</Objects> 
PS (7) >
This simplifies the output even further. It makes sense if the target consumer for the 
generated document isn’t a .
NET
-based application and therefore wouldn’t be able to 
do much with the type names.
The 
ConvertTo-XML
cmdlet is useful for interoperation with non-PowerShell 
applications, but for PowerShell-to-PowerShell communication, too much informa-
tion is lost. For the PowerShell-to-PowerShell scenario, a much better solution is to 
use the 
Export-Clixml
and 
Import-Clixml
cmdlets. We’ll cover these next.
The Import-Clixml and Export-Clixml cmdlets
The next two cmdlets we’re going to cover are 
Import-Clixml
and 
Export-Clixml
These cmdlets provide a way to save and restore collections of objects from the Pow-
erShell environment with higher fidelity (less data loss) than the 
ConvertTo-Xml 
cmdlet. The signature for 
Export-Clixml
is shown in figure 16.5.
The encoding these cmdlets use is essentially what PowerShell remoting uses to 
send objects between hosts, as discussed in chapter 12 (section 12.6.5). 
Export-Clixml 
-InputObject <PSObject>
[-Path] <String>
[-Depth <Int32>]  
[-Force] 
[-NoClobber]
[-Encoding <String>]
Cmdlet name
Specifes depth of
subproperties to include 
in output document;
default is 1
Object to convert to
XML document
Path to write
output file to
Force overwriting
existing files even if
they’re marked 
read-only 
Don’t overwrite
(clobber) existing file
even if it’s writable
Character encoding to use when writing
the file: ASCII, UTF8 (default), UTF7, 
UTF32, Unicode, BigEndianUnicode,
Default, or OEM
Figure 16.5 The 
Export-Clixml
cmdlet is used to export or serialize PowerShell objects 
to a file using an encoding similar to the remoting protocol object encoding.
DICOM to PDF Converter | Convert DICOM to PDF, Convert PDF to
Adobe Acrobat or any other print drivers when they use DICOM to PDF Converter. Additionally, high-quality image conversion of DICOM & PDF files in single page
rearrange pages in pdf reader; how to rearrange pdf pages
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
interface; Powerful image converter for Bitmap and PDF files; No need for Adobe Acrobat Reader & print driver during conversion; Support
how to move pages in pdf; reorder pages in pdf reader
XML 
STRUCTURED
TEXT
PROCESSING
715
To recap our discussion, we mentioned that there’s only a small set of types that 
serialize with fidelity and that other types are shredded into property bags. With the
*-
Clixml
cmdlets, you can see what the encoding looks like. Let’s try this out. First, 
create a collection of objects: a hashtable, a string, and some numbers:
PS (1) > $data = @{a=1;b=2;c=3},"Hi there", 3.5
Now serialize them to a file using the Export-Clixml cmdlet:
PS (2) > $data | Export-Clixml out.xml
Let’s see what the file looks like:
PS (3) > type out.xml 
<Objs Version="1.1.0.1" 
xmlns="http://schemas.microsoft.com/powershell/2004/04">
<Obj RefId="0">
<TN RefId="0">
<T>System.Collections.Hashtable</T>
<T>System.Object</T>
</TN>
<DCT>
<En>
<S N="Key">a</S>
<I32 N="Value">1</I32>
</En>
<En>
<S N="Key">b</S>
<I32 N="Value">2</I32>
</En>
<En>
<S N="Key">c</S>
<I32 N="Value">3</I32>
</En>
</DCT>
</Obj>
<S>Hi there</S>
<Db>3.5</Db> 
</Objs>
This first part identifies the schema for the 
CLIXML
object representation:
<Objs Version="1.1.0.1" 
xmlns="http://schemas.microsoft.com/powershell/2004/04">
<Obj RefId="0">
<TN RefId="0">
<T>System.Collections.Hashtable</T>
<T>System.Object</T>
</TN>
<DCT>
Here are the key-value pair encodings:
<En>
<S N="Key">a</S>
716
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
<I32 N="Value">1</I32>
</En>
<En>
<S N="Key">b</S>
<I32 N="Value">2</I32>
</En>
<En>
<S N="Key">c</S>
<I32 N="Value">3</I32>
</En>
Now encode the string element
<S>Hi there</S>
and the double-precision number:
<Db>3.5</Db>
Import these objects back into the session using 
Import-Clixml
PS (5) > $new_data = Import-Clixml out.xml
and compare the old and new collections:
PS (6) > $new_data
Name                           Value 
----                           -----
                             1 
                             2 
                             3 
Hi there
3.5
PS (7) > $data
Name                           Value 
----                           -----
                             1 
                             2 
                             3 
Hi there
3.5
They match, member for member.
These cmdlets provide a simple way to save and restore collections of objects, but 
they have limitations. They can only load and save a fixed number of primitive types. 
Any other type is “shredded,” which means it’s broken apart into a property bag com-
posed of these primitive types. This allows any type to be serialized but with some 
loss of fidelity. In other words, objects can’t be restored to exactly the same type they 
were originally. This approach is necessary because there can be an infinite number of 
object types, not all of which may be available when the file is read back. Sometimes
S
UMMARY
717
you don’t have the original type definition. Other times, there’s no way to re-create 
the original object, even with the type information, because the type doesn’t support 
this operation. By  restricting  the set of types that are serialized with fidelity,  the 
Clixml
format can always recover objects regardless of the availability of the original 
type information.
There’s also another limitation on how objects are serialized. An object has prop-
erties. Those properties are also objects that have their own properties, and so on. 
This chain of properties that have properties is called the serialization depth. For some 
of the complex objects in the system, such as the 
Process
object, serializing through 
all the levels of the object results in a huge 
XML
file. To constrain this, the serializer 
only traverses to a certain depth. The default depth is 2. You can override this default 
either on the command line using the 
-Depth
parameter or by placing a 
<Serial-
izationDepth>
element in the type’s description file. If you look at 
$PSHome/ 
types.ps1xml
, you can see some examples of where this has been done.
16.5
S
UMMARY
In this chapter, we covered the kind of tasks that are the traditional domain of script-
ing languages  and  shells:  paths,  files and  text  processing. You  learned about the 
following:
• Basic  text processing—how  to  split  and join  strings using  the 
[string]:: 
Split()
and 
[string]::Join()
methods to augment the 
-split
and 
-join 
operators.
• More advanced text processing with the 
[regex]
class. You saw how to use this 
class to conduct more advanced text operations such as tokenizing a string.
• The core cmdlets and how they correspond to the commands in other shell 
environments.
• How to set up shortcuts to long or specialized paths in the file system using 
New-PSDrive
. For example
New-PSDrive AppData FileSystem "$Home\Application Data"
creates a drive named AppData mapped to the root of the current user’s Appli-
cation Data directory.
• How  to  read  and  write  files  in  PowerShell  using 
Get-Content
and 
Set-
Content
, and how to deal with character encodings in text files.
• How to work with binary files. You wrote a of couple handy utility functions in 
the process.
• Using the 
Select-String
cmdlet to efficiently search through collections of 
files.
• The basic support in PowerShell for 
XML
documents in the form of the 
XML 
object adapter. PowerShell provides a shortcut for creating an 
XML
document
718
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
with the 
[xml]
type accelerator. For example: 
[$xml]"<docroot>...</doc-
root>"
.
• How to construct 
XML
documents by adding elements to an existing document 
using the 
CreateElement()
method.
• Using  the 
XmlReader
class to search 
XML
documents without  loading the 
whole document into memory.
• Building utility functions for searching and formatting 
XML
documents.
• Examples of processing 
XML
documents using PowerShell pipelines.
• Extracting content from 
XML
documents using the 
XP
ath language.
• How to save and restore collections of objects using 
ConvertTo-Xml
Import-
Clixml
, and 
Export-Clixml
.
In this chapter, in working with paths, files, and text, you used a number of the .
NET 
Framework features do your work. In the next chapter, we’ll build on this knowledge. 
The main focus of chapter 17 is how to use more of the .
NET F
ramework to do some 
of the things that aren’t built into PowerShell as cmdlets, including how to write a 
graphical front end to your scripts.
719
C
H
A
P T E R   1 7
Extending your reach 
with .
NET
17.1  Using .NET from PowerShell  720
17.2  PowerShell and the internet  740
17.3  PowerShell and graphical user 
interfaces  743
17.4  Summary  759
I love it when a plan comes together!
—Col. John “Hannibal” Smith, The A-Team
When we started the design work on PowerShell, our focus was almost exclusively on 
cmdlets. The plan was to have lots of cmdlets and everything would be done through 
them. Unfortunately, as Robert Burns observed, “The best laid plans of mice and 
men often go awry,” and we found that we didn’t have the resources to get all the 
required cmdlets completed in time. Without these cmdlets, we wouldn’t have ade-
quate coverage for all of our core scenarios. How to solve this, we asked? “Let’s just 
depend on .
NET
,” was the answer. We decided to make it easier to work directly with 
the .
NET
F
ramework. That way, although it might not be as easy to do everything the 
way we wanted, at least it would be possible.
In retrospect, this may have been one of the best things to happen to PowerShell. 
Not only did we backfill our original scenarios, but the set of problem domains (such
Documents you may be interested
Documents you may be interested