c# pdf viewer itextsharp : Move pdf pages in preview control software platform web page windows asp.net web browser Windows%20Powershell%20in%20Action%202nd%20Edition73-part1531

700
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
<d>
Hello there world
</d> 
</top>
which is close to the original document. The code for the 
Format-XmlDocument 
function is shown in the next listing.
function global:Format-XmlDocument ($doc="$PWD\fancy.xml") 
{
$settings = New-Object System.Xml.XmlReaderSettings 
$doc = (Resolve-Path $doc).ProviderPath
$reader = [System.Xml.XmlReader]::create($doc, $settings)
$indent=0
function indent ($s) { "  "*$indent+$s }
while ($reader.Read())
{
if ($reader.NodeType -eq [Xml.XmlNodeType]::Element)
{
$close = $(if ($reader.IsEmptyElement) { "/>" } else { ">" })
if ($reader.HasAttributes)          
{
$s = indent "<$($reader.Name) "
[void] $reader.MoveToFirstAttribute()      
do                                              
                                              
$s += "$($reader.Name) = `"$($reader.Value)`" " 
                                                
while ($reader.MoveToNextAttribute())        
"$s$close"
}
else
{
indent "<$($reader.Name)$close"
}
if ($close -ne '/>') {$indent++}      
}
elseif ($reader.NodeType -eq [Xml.XmlNodeType]::EndElement )
{
$indent--
indent "</$($reader.Name)>"               
}
elseif ($reader.NodeType -eq [Xml.XmlNodeType]::Text)
{
indent $reader.Value                       
}
}
$reader.close()            
}
Format-XmlDocument
is a complex function, so it’s worthwhile to take it one piece 
at a time. Let’s start with the basic function declaration, where it takes an optional
Listing16.4    The Format-XmlDocument function
Create settings 
object
b
Define formatting 
function
c
Process 
element nodes
d
Increase 
indent level
e
Format text 
element
f
Move pdf pages in preview - 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 rearrange pages in a pdf document; reorder pages in pdf online
Move pdf pages in preview - 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 in pdf acrobat; move pages in pdf reader
XML 
STRUCTURED
TEXT
PROCESSING
701
argument that names a file. Next you create the settings object 
B
you need to pass in 
when you create the 
XML
reader object. You also need to resolve the path to the doc-
ument, because the 
XML
reader object requires an absolute path (see chapter 17 for 
an explanation of why this is). Now you can create the 
XmlReader
object itself. The 
XML
reader will stream through the document, reading only as much as it needs, as 
opposed to reading the entire document into memory.
You want to display the levels of the document indented, so you initialize an 
indent level counter and a local function 
c
to display the indented string. Now 
you’ll read through all of the nodes in the document. You’ll choose different behavior 
based on the type of the node. An element node 
d
is the beginning of an 
XML
ele-
ment. If the element has attributes, then you’ll add them to the string to display. 
You’ll use the 
MoveToFirstAttribute()
and 
MoveToNextAttribute()
methods 
to move through the attributes. (Note that this pattern parallels the enumerator pat-
tern you saw in chapter 5 with the 
$foreach
and 
$switch
enumerators.) If there are 
no attributes, just display the element name. At each new element, increase 
e
the 
indent level if it’s not an empty element tag. If it’s the end of an element, decrease the 
indent level and display the closing tag. If it’s a text element, just display the value of 
the element 
f
. Finally, close the reader. You always want to close a handle received 
from a .
NET
method. It’ll eventually be discarded during garbage collection, but it’s 
possible to run out of handles before you run out of memory.
This example illustrates the basic techniques for using an 
XML
reader object to 
walk through an arbitrary document.
But where are the pipelines, you ask? Neither of these last two examples has taken 
advantage of PowerShell’s pipelining capability. In the next section, we’ll remedy this 
omission.
16.4.4
Processing XML documents in a pipeline
Pipelining is one of the signature characteristics of shell environments in general and 
PowerShell in particular. Because the previous examples didn’t take advantage of this 
feature, we’ll look at how it can be applied. You’re going to write a function that scans 
all the PowerShell help files, both the text about topics and the 
XML
files.
NOTE
PowerShell v1 didn’t have a way to search help, so this exam-
ple is useful as well as illustrative. In PowerShell v2, the 
Get-Help 
cmdlet was enhanced to search all help using wildcards.
For example, let’s search for all the help topics that mention the word “scriptblock”:
PS (1) > Search-Help scriptblock 
about_Display 
about_Types 
Get-Process 
Group-Object 
Measure-Command 
Select-Object
How to C#: Preview Document Content Using XDoc.Word
How to C#: Preview Document Content Using XDoc.Word. Get Preview From File. You may get document preview image from an existing Word file in C#.net.
move pages in pdf acrobat; move pages in pdf online
How to C#: Preview Document Content Using XDoc.PowerPoint
How to C#: Preview Document Content Using XDoc.PowerPoint. Get Preview From File. You may get document preview image from an existing PowerPoint file in C#.net.
reorder pdf page; reorder pdf pages
702
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
Trace-Command
ForEach-Object 
Where-Object
This tool provides a simple, fast way to search for all the help topics that contain a 
particular pattern. The source for the function is shown in this listing.
function Search-Help 
{
param ($pattern = $(throw "you must specify a pattern"))
Select-String -List $pattern $PSHome\about*.txt |
%{$_.filename -replace '\..*$'}
dir $PShome\*dll-help.*xml |
foreach { [xml] (get-content -read -1 $_) } |
foreach{$_.helpitems.command} |
where {$_.get_Innertext() -match $pattern} |
foreach {$_.details.name.trim()} 
}
The 
Search-Help
function takes one parameter to use as the pattern for which 
you’re searching. Listing 16.5 uses the 
throw
keyword described in chapter 14 to gen-
erate an error if the parameter wasn’t provided.
First,  you search all the text  files in the PowerShell installation directory and 
return one line for each matching file. Then you pipe this line into 
ForEach-Object 
(or, more commonly, its alias 
foreach
) to extract the base name of the file using the 
-replace
operator and a regular expression. This operation will list the filenames in 
a form that you can type back into 
Get-Help
.
Next, you get a list of the 
XML
help files and turn each file into an 
XML
object. 
You specify a read count of -1 so the whole file is read at once. You extract the com-
mand elements from the 
XML
document and then see if the text of the command 
contains the pattern you’re looking for. If it does, then you emit the name of the 
command, trimming off unnecessary spaces.
As well as being a handy way to search help, this function is a nice illustration of 
using the divide-and-conquer strategy when writing scripts in PowerShell. Each step 
in the pipeline brings you incrementally closer to the final solution.
Now that you know how to manually navigate through an 
XML
document, let’s 
look at some of the .
NET F
ramework’s features that make navigation a bit easier and 
more efficient.
16.4.5
Processing XML with XPath
The support for 
XML
in the .
NET F
ramework is extensive so we can’t possibly cover 
all of it in this book. There is, however, one more useful thing that we want to cover:
Listing 16.5    Search-Help
C# Word - Sort Word Pages Order in C#.NET
page reorganizing library control, developers can swap or adjust the order of all or several Word document pages, or just C# DLLs: Move Word Page Position.
change pdf page order preview; how to rearrange pdf pages reader
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the C# DLLs: Move PowerPoint Page Position.
how to rearrange pdf pages online; rearrange pages in pdf
XML 
STRUCTURED
TEXT
PROCESSING
703
the 
XML
Path Language, also known as 
XP
ath. This is a path-based pattern language, 
which means it’s like the collision between paths, wildcards, and regular expressions. 
It’s useful because it gives you a fast, concise way to select pieces of information from 
an 
XML
document.
In PowerShell v1, you had to work with the raw .
NET
classes to be able to use 
XP
ath.  PowerShell v2 introduced  a new cmdlet, 
Select-Xml
 that  makes 
XP
ath 
much more accessible. In this section, we’ll look at how XPath expressions work and 
use them to extract information from documents. We’ll start with a short overview of 
the XPath fundamentals.
XPath basics
XP
ath is another domain-specific  language, this time for specifying  patterns  that 
allow you to concisely extract information from 
XML
documents. You’ve already seen 
patterns for working with hierarchies in the file system in the form of file path and 
wildcards. You’ve worked with text-oriented pattern languages like regular expres-
sions. 
XP
ath combines these two concepts into a single mechanism for accessing data 
in an 
XML
document. An 
XP
ath expression can be used to extract nodes, content, or 
attributes from a document. It also allows calculations to be used in the expressions to 
get even greater flexibility. Table 16.2 shows the basic patterns in this language and 
the corresponding commands you’d use in the file system.
Things get a bit more complex because 
XML
allows for multiple nodes with the same 
name and allows attributes on nodes. Next, we’ll set up a test document and explore 
these more complex patterns.
Setting up the test document
You’ll work through a couple of examples using 
XP
ath, but first you need a document 
to process. The following script fragment creates a string you’ll use for the examples. 
It’s a fragment of a bookstore inventory database. Each record in the database has the
Table 16.2 Examples of basic XPath patterns
XPath expression
Description
Equivalent file operation
/
Gets all of the nodes under the document root dir /
.
Selects the current node
Get-Item .
..
Selects the parent node
Get-Item ..
A
Selects all of the children under node a
dir a
/a/b/c
Gets all nodes under path /a/b/c
dir /a/b/c
//b
Gets all elements with the name b anywhere in 
the document
dir -rec -Filter b
C# PDF insert text Library: insert text into PDF content in C#.net
adding text to PDF in preview without adobe int pageIndex = 0; // Move cursor to (400F, 100F). outputFilePath = Program.RootPath + "\\" output.pdf"; doc.Save
how to rearrange pdf pages in preview; how to move pages within a pdf document
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview component enables compressing and
move pages in pdf file; move pages within pdf
704
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
name of the author, the book title, and the number of books in stock. Save this string 
in a variable called 
$inventory
, as shown in this listing.
$inventory = @"
<bookstore>
<book genre="Autobiography">
<title>The Autobiography of Benjamin Franklin</title>
<author>
<first-name>Benjamin</first-name>
<last-name>Franklin</last-name>
</author>
<price>8.99</price>
<stock>3</stock>
</book>
<book genre="Novel">
<title>Moby Dick</title>
<author>
<first-name>Herman</first-name>
<last-name>Melville</last-name>
</author>
<price>11.99</price>
<stock>10</stock>
</book>
<book genre="Philosophy">
<title>Discourse on Method</title>
<author>
<first-name>Rene</first-name>
<last-name>Descartes</last-name>
</author>
<price>9.99</price>
<stock>1</stock>
</book>
<book genre="Computers">
<title>Windows PowerShell in Action</title>
<author>
<first-name>Bruce</first-name>
<last-name>Payette</last-name>
</author>
<price>39.99</price>
<stock>5</stock>
</book>
</bookstore>
"@
Now that you’ve created your test document, let’s see what you can do with it.
The Select-Xml cmdlet
PowerShell v2 introduced the 
Select-Xml
cmdlet, which allows you to do 
XP
ath 
queries without resorting to the raw .
NET
F
ramework. The syntax for this cmdlet is 
shown in figure 16.3.
Listing16.6    Creating the bookstore inventory
VB.NET PDF insert text library: insert text into PDF content in vb
Add text to PDF in preview without adobe reader Dim pageIndex As Integer = 0 ' Move cursor to (400F As String = Program.RootPath + "\\" output.pdf" doc.Save
reverse page order pdf online; change pdf page order reader
How to C#: Preview Document Content Using XDoc.excel
How to C#: Preview Document Content Using XDoc.Excel. Get Preview From File. You may get document preview image from an existing Excel file in C#.net.
pdf reverse page order preview; how to reorder pdf pages in
XML 
STRUCTURED
TEXT
PROCESSING
705
You’re going to use this cmdlet in most of the examples in this section. Let’s start with 
something very simple, getting the bookstore node at the root of the document:
PS (1) > Select-Xml -Content $inventory -XPath /bookstore
Node                    Path                   Pattern 
----                    ----                   -------
bookstore               InputStream            /bookstore
Unfortunately, the output doesn’t look very promising. The node object you’re after is 
mixed in with the context of the query: where the processed text came from and what 
the query was. To extract the node object, you just have to reference it as a property:
PS (2) > (Select-Xml -Content $inventory -XPath /bookstore).Node
book 
----
{book, book, book, book}
This output shows that there are four child nodes under bookstore. So extend your 
query to get these child items in a similar manner to how you could get the contents 
of a directory in the file system:
PS (3) > Select-Xml -Content $inventory -XPath /bookstore/book
Node                    Path                   Pattern 
----                    ----                   -------
book                    InputStream            /bookstore/book 
book                    InputStream            /bookstore/book 
book                    InputStream            /bookstore/book 
book                    InputStream            /bookstore/book
And here’s the nested-node issue again.  Again you have to use  the  .  operator  to 
retrieve the actual content. This works for one node
PS (4) > (Select-Xml -Content $inventory ` 
>>   -XPath /bookstore/book)[0].Node 
>>
Select-XML 
-Content <string[]>
[-Path] <string[]>
[-Xml] <XmlNode[]>
[-Xpath]  <string>
[-Namespace <hashtable>]
Cmdlet name
Xpath pattern
to search for
Optionally used to specify
XML name space to search
Search for files, strings, or XML objects
(only one of these can be specified); 
if string is specified as first positional 
argument, it’s treated as file path,
not content
Figure 16.3 The 
Select-Xml
cmdlet parameters. This cmdlet allows you to perform 
XPath queries on XML documents stored in files or strings.
706
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
genre  : Autobiography 
title  : The Autobiography of Benjamin Franklin 
author : author 
price  : 8.99 
stock  : 3
but it won’t work for the entire collection. For each of the nodes, you need to extract 
the 
Node
property, and so you apply the 
foreach
cmdlet:
PS (5) > Select-Xml -Content $inventory -XPath /bookstore/book | 
>> foreach { $_.node } 
>>
genre  : Autobiography 
title  : The Autobiography of Benjamin Franklin 
author : author 
price  : 8.99 
stock  : 3
genre  : Novel 
title  : Moby Dick 
author : author 
price  : 11.99 
stock  : 10
genre  : Philosophy 
title  : Discourse on Method 
author : author 
price  : 9.99 
stock  : 1
genre  : Computers 
title  : Windows PowerShell in Action 
author : author 
price  : 39.99 
stock  : 5
This time you see the properties of all four nodes. If you want to extract just the title 
nodes, add 
title
to the end of the path:
PS (6) > Select-Xml -Content $inventory -XPath /bookstore/book | 
>> foreach { $_.node.title } 
>>
The Autobiography of Benjamin Franklin 
Moby Dick 
Discourse on Method 
Windows PowerShell in Action 
PS (7) > Select-Xml -Content $inventory ` 
>> -XPath /bookstore/book/title | 
>> foreach { $_.node } 
>>
#text 
-----
The Autobiography of Benjamin Franklin
XML 
STRUCTURED
TEXT
PROCESSING
707
Moby Dick
Discourse on Method 
Windows PowerShell in Action
At this point, using 
foreach
all the time is getting tedious, so let’s define a filter to 
simplify this:
PS (8) > filter node { $_.node }
This filter will make the examples a little less messy.
Now let’s look at  some more advanced examples. So far, you’ve returned the 
entire set of nodes, but when querying for some information, you usually just want to 
get part of that information. You can do this quite easily with the 
Where-Object 
cmdlet:
PS (9) > Select-Xml -Content $inventory -XPath /bookstore/book | 
>> node | where { [double] ($_.price) -lt 10} 
>>
genre  : Autobiography 
title  : The Autobiography of Benjamin Franklin 
author : author 
price  : 8.99 
stock  : 3
genre  : Philosophy 
title  : Discourse on Method 
author : author 
price  : 9.99 
stock  : 1
This example retrieves all the books priced less than $10. 
XP
ath has built-in function-
ality that’s similar to the 
Where-Object
cmdlet: predicate expressions. These expres-
sions appear in the path surrounded by square brackets and can contain simple logical 
expression.  Nodes where  the  expression evaluates  to true are returned.  Here’s  an 
example that uses a predicate expression in the 
XP
ath path to do the same thing you 
did with the 
Where-Object
cmdlet:
PS (10) > Select-Xml -Content $inventory ` 
>> -XPath '/bookstore/book[price < 10]' | 
>> node 
>>
genre  : Autobiography 
title  : The Autobiography of Benjamin Franklin 
author : author 
price  : 8.99 
stock  : 3
genre  : Philosophy 
title  : Discourse on Method 
author : author 
price  : 9.99 
stock  : 1
708
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
You get the same result in both cases. Notice that in the predicate expression you were 
able to reference 
price
directly as opposed to 
[double] ($_.price)
the way you 
did in the 
switch
case. Because the expression is being executed by the 
XP
ath engine, 
it can make these optimizations, simplifying the reference to the price item and treat-
ing it as a number automatically.
In the previous example, the 
price
item was actually a path relative to the current 
node. You can use things like 
..
to reference the parent node. Let’s write our expres-
sion so that it returns only the titles of the books whose price is less than $10:
PS (11) > Select-Xml -Content $inventory ` 
>> -XPath '/bookstore/book/title[../price < 10]' | 
>> node 
>>
#text 
-----
The Autobiography of Benjamin Franklin 
Discourse on Method
The path selects the 
title
node but filters on the path 
../price
, which is a sibling 
to the 
title
node.
As we discussed earlier,  elements are all  that an 
XML
document can contain. 
Another  major  item  is  the  attribute. 
XP
ath  allows  an  attribute  to  be  referenced 
instead of an element by prefixing the name with 
@
, as you see here:
PS (12) > Select-Xml -Content $inventory -XPath '//@genre' | node
#text 
-----
Autobiography 
Novel 
Philosophy 
Computers
This example shows the 
genre
attribute for each of the book nodes. You can also use 
attributes in predicate expressions in the path:
PS (13) > Select-Xml -Content $inventory ` 
>> -XPath '//book[@genre = "Novel"]' | 
>> node 
>>
genre  : Novel 
title  : Moby Dick 
author : author 
price  : 11.99 
stock  : 10
This example uses the 
@genre
attribute in the node to only return books in the Novel 
genre. Note that, unlike the PowerShell relational operators, 
XP
ath operators are case 
sensitive. If you specify 
novel
for the genre instead of 
Novel
PS (14) > Select-Xml -Content $inventory ` 
>> -XPath '//book[@genre = "novel"]' |
XML 
STRUCTURED
TEXT
PROCESSING
709
>> node 
>>
nothing is retrieved, whereas doing the same thing with the 
Where-Object
cmdlet 
works just fine:
PS (15) > Select-Xml -Content $inventory ` 
>> -XPath '//book' | node | 
>> where {$_.genre -eq 'novel' } 
>>
genre  : Novel 
title  : Moby Dick 
author : author 
price  : 11.99 
stock  : 10
This  should make it clear that 
XP
ath  is its  own language and doesn’t necessarily 
behave the same way as the equivalent expression in PowerShell.
Now let’s do some processing on the data in the document instead of just retriev-
ing the node. In this example, you’ll calculate the total value of the inventory, which 
is the sum of the product of multiplying the 
price
node and the 
stock
node:
PS (16) > Select-Xml -Content $inventory ` 
>> -XPath '//book' | node | 
>> foreach {[double] $_.price * $_.stock } | 
>> Measure-Object -Sum | foreach { $_.sum } 
>> 
356.81
This code uses 
XP
ath to extract the relevant nodes and then uses PowerShell to per-
form the calculations.
The examples in this section illustrate the basic mechanism for using 
XP
ath to 
extract data from documents. They’re far from comprehensive, though. There’s a lot 
more to learn about the details of the 
XP
ath language—the functions it supports, 
how to do calculations, and so forth—but this level of detail is probably not needed 
for most scenarios because PowerShell can do all of these things in a much more 
flexible way.
In this section, we introduced 
XP
ath as a well-known, standard way of accessing 
documents. It’s an effective tool, but it involves learning an entirely separate language 
for expression queries. Microsoft addressed this multilanguage issue (for 
SQL
as well 
as 
XML
 by  introducing  a  .
NET
feature  called  the  Language  Integrated  Query 
(LINQ)
. The flavor of 
LINQ
for 
XML
is called 
XL
inq and is a new 
API
for working 
with 
XML
. We’ll briefly touch on this in the next section.
16.4.6
A hint of XLinq
XP
ath is a domain-specific language 
(DSL)
for querying 
XML
documents—which 
means that you must learn new syntax and semantics to use it. With 
XL
inq, you just 
have to learn a few new methods and not a new syntax.
Documents you may be interested
Documents you may be interested