c# pdf viewer itextsharp : Reorder pages pdf software Library cloud windows asp.net web page class Windows%20Powershell%20in%20Action%202nd%20Edition72-part1530

690
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
Searching through files this way can sometimes produce more results than you really 
need. We’ll show you how to control what’s returned next.
Using the -List and -Quiet parameters
Now  let’s  try  out  the 
-List
parameter. Normally 
Select-String
will find all 
matches in a file. The 
-List
switch limits the search to only the first match in a file:
PS (4) > Select-String -List wildcard $pshome/en-US/about*.txt
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_aliases.help.txt:147:     Property parameter of 
Format-List with
a wildcard character (*) to display 
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_Comment_Based_Help.help.txt:377:      Accept wildcard 
characters?
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_Comparison_Operators.help.txt:90:      Description: Match using 
the wildcard character (*). 
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_Language_Keywords.help.txt:339:          switch 
[-regex|-wildcard|-exact][-casesensitive] ( pipeline ) 
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_operators.help.txt:47:      the like operators 
(-like, -notlike), which find patterns using wildcard 
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_parameters.help.txt:53:    wildcard character (*) with 
the Parameter parameter to find information 
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_pipelines.help.txt:272:           Accept wildcard characters? 
true 
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_properties.help.txt:112:     more properties and their values. 
Or, you can use the wildcard 
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_remote_troubleshooting.help.txt:140:    Enable the policy and 
specify the IPv4 and IPv6 filters. Wildcards (*) are 
C:\Windows\System32\WindowsPowerShell\v1.0\en-US\about_Switch.help.txt:65: 
switch [-regex|-wildcard|-exact][-casesensitive] ( pipeline ) 
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_wildcards.help.txt:2:    about_Wildcards
In the result, you see exactly one match per file. Try using the 
-Quiet
switch:
PS (5) > Select-String -Quiet wildcard $pshome/en-US/about*.txt 
True
This switch returns 
$true
if any of the files contained a match and 
$false
if none of 
them did. You can also combine the two switches so that the cmdlet returns the first 
match in the set of files:
Reorder pages pdf - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
reorder pdf pages; change page order pdf acrobat
Reorder pages 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
pdf move pages; change page order pdf reader
P
ROCESSING
UNSTRUCTURED
TEXT
691
PS (6) > Select-String -Quiet -List wildcard $pshome/en-US/about*.txt
C:\Windows\System32\WindowsPowerShell\v1.0\en-
US\about_aliases.help.txt:147:     Property parameter of 
Format-List with
a wildcard character (*) to display
Searching a tree of files
If you want to search a more complex set of files, you can pipe the output of 
Get-
ChildItem
into the cmdlet and it will search all of these files. Let’s search all the log 
files in the 
system32
subdirectory:
PS (7) > Get-ChildItem -rec -Filter *.log $env:windir\system32 | 
>> Select-String -List fail | Format-Table path 
>>
Path 
----
C:\WINDOWS\system32\CCM\Logs\ScanWrapper.LOG 
C:\WINDOWS\system32\CCM\Logs\UpdateScan.log 
C:\WINDOWS\system32\CCM\Logs\packages\RMSSP1_Client_RTW.log 
C:\WINDOWS\system32\CCM\Logs\packages\RMSSP1_Client_RTW_BC_In... 
C:\WINDOWS\system32\wbem\Logs\wbemcore.log 
C:\WINDOWS\system32\wbem\Logs\wbemess.log 
C:\WINDOWS\system32\wbem\Logs\wmiadap.log 
C:\WINDOWS\system32\wbem\Logs\wmiprov.log
Notice that you’re only displaying the path. The output of 
Select-String
is objects, 
as shown:
PS (3) > Select-String wildcard $PSHOME/en-US/about*.txt | 
>> Get-Member -type property 
>>
TypeName: Microsoft.PowerShell.Commands.MatchInfo
Name       MemberType Definition 
----       ---------- ----------
Context    Property   Microsoft.PowerShell.Commands.MatchInfo... 
Filename   Property   System.String Filename {get;}
IgnoreCase Property   System.Boolean IgnoreCase {get;set;}
Line       Property   System.String Line {get;set;}
LineNumber Property   System.Int32 LineNumber {get;set;} 
Matches    Property   System.Text.RegularExpressions.Match[] ... 
Path       Property   System.String Path {get;set;}
Pattern    Property   System.String Pattern {get;set;}
With these fields, there are many things you can do by selecting specific members. 
For example, the filename can be used to open the file in an editor and the 
Line 
number can be used to set the line in the file to the matching item. In the next sec-
tion, we’ll look at some of the more exotic properties on the 
MatchInfo
object.
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.
pdf page order reverse; how to reverse pages in pdf
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
move pages in pdf; how to move pages in a pdf file
692
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
Searching with contexts
In the output from 
Get-Member
, you can see that there’s a context property. This 
property allows you to have 
Select-String
include the lines before and after the 
matching line:
PS (1) > Get-Help Select-String | 
>> Out-String -Stream | 
>> Select-String syntax -Context 3 
>>
Finds text in strings and files.
> SYNTAX
Select-String [-Path] <string[]> [-Pattern] <string[]> [-All
Matches] [-CaseSensitive] [-Context <Int32[]>] [-Encoding 
<string>] [-Exclude <string[]>] [-Include <string[]>] [-List] 
]
This code gets the lines you want but it also gets the lines before the target that you 
don’t want. You can solve this issue by specifying two numbers to the parameter. The 
first number is the length of the prefix context and the second is the suffix context. So 
to get what you want, you just have to specify a prefix context of 0. The result looks 
like this:
PS (2) > Get-Help Select-String | 
>> Out-String -Stream | 
>> Select-String syntax -Context 0,3 
>>
> SYNTAX
Select-String [-Path] <string[]> [-Pattern] <string[]>
[-All Matches] [-CaseSensitive] [-Context <Int32[]>]
[-Encoding <string>] [-Exclude <string[]>]
[-Include <string[]>] [-List]
Getting all matches in the line
Another property on the 
MatchInfo
object is the 
Matches
property. This property is 
used when the 
-AllMatches
switch is specified to the cmdlet. It causes all matches in 
the line to be returned instead of just the first match. You’ll use this switch to perform 
the same type of tokenization that you did with regular expressions in section 16.2.2. 
You’ll pipe the expression string into 
Select-String
with the 
-AllMatches
switch 
and the same regular expression you used earlier:
PS (12) > "1 + 2 *3" | 
>>    Select-String -AllMatches "[0-9]+|\+|\-|\*|/| +" | 
>>    foreach { $_.Matches } | Format-Table -AutoSize 
>>
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
pdf change page order; reordering pages in pdf
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
how to rearrange pages in a pdf reader; change page order in pdf file
XML 
STRUCTURED
TEXT
PROCESSING
693
Groups Success Captures Index Length Value 
------ ------- -------- ----- ------ -----
{1}       True {1}          0      1 1 
{ }       True { }          1      1 
{+}       True {+}          2      1 + 
{ }       True { }          3      1 
{2}       True {2}          4      1 2 
{ }       True { }          5      1
{*}       True {*}          6      1 * 
{3}       True {3}          7      1 3
You used the 
foreach
cmdlet to isolate the 
Matches
property and then formatted 
the output as a table. You can see each of the extracted tokens in the 
Value
field in 
the 
Matches
object. Using this mechanism, you can effectively and efficiently process 
things like large log files where the output is essentially formatted as a table.
So far in this chapter, we’ve looked at manipulating text with PowerShell opera-
tors, .
NET
methods, and finally the 
Select-String
cmdlet. All of this text has been 
unstructured text where there’s no rigorously defined layout for that text. As a conse-
quence, you’ve had to work fairly hard to extract the information you want out of 
this text. There are, however, large bodies of structured text, where the format is well 
defined in the form of 
XML
documents. In the next section, we’ll show you how to 
work with 
XML
in PowerShell.
16.4
XML 
STRUCTURED
TEXT
PROCESSING
XML (Extensible Markup Language) is becoming increasingly important in the com-
puting world. 
XML
is being used for everything from configuration files to log files to 
databases. PowerShell uses 
XML
for its type and configuration files as well as for the 
help files. For PowerShell to be effective, it has to be able to process 
XML
documents 
effectively. Let’s look at how 
XML
is used and supported in PowerShell.
NOTE
This  section assumes  you  possess  some  basic knowledge  of 
XML
markup.
We’ll look at the 
XML
object type, as well as the mechanism that .
NET
provides for 
searching 
XML
documents.
16.4.1
Using XML as objects
PowerShell supports 
XML
documents as a core data type. This means that you can 
access  the elements of  an 
XML
document as though they  were properties on an 
object. For example, let’s create a simple 
XML
object. Start with a string that defines a 
top-level node called 
top
. This node contains three descendants: 
a
b
, and 
c
, each of 
which has a value. Let’s turn this string into an object:
PS (1) > $d = [xml] "<top><a>one</a><b>two</b><c>3</c></top>"
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
how to rearrange pages in pdf document; moving pages in pdf
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.
reorder pdf pages in preview; rearrange pages in pdf file
694
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
The 
[xml]
cast takes the string and converts it into an 
XML
object of type 
Sys-
tem.XML.XmlDocument
. This object is then adapted by PowerShell so you can treat it 
like a regular object. Let’s try this out. First, display the object:
PS (2) > $d
top 
---
top
As you expect, the object displays one top-level property corresponding to the top-
level node in the document. Now let’s see what properties this node contains:
PS (4) > $d.top
                    b                     c 
                    -                     -
one                   two                   3
There are three properties that correspond to the descendants of 
top
. You can use 
conventional property notation to look at the value of an individual member:
PS (5) > $d.top.a
One
Modifying this node is as simple as assigning a new value to the node. Let’s assign the 
string “Four” to the node 
a
:
PS (6) > $d.top.a = "Four"
PS (7) > $d.top.a 
Four
You can see that it’s been changed. But there’s a limitation: you can only use an actual 
string as the node value. The 
XML
object adapter won’t automatically convert nonstring 
objects to strings in an assignment, so you get an error when you try it, as seen here:
PS (8) > $d.top.a = 4
Cannot set "a" because only strings can be used as values to 
set XmlNode properties.
At line:1 char:8 
+ $d.top.a <<<<  = 4
All of the normal type conversions apply, of course. The node 
c
contains a string 
value that’s a number:
PS (8) > $d.top.c.gettype().FullName 
System.String
You can add this field to an integer, which will cause it to be converted into an integer:
PS (9) > 2 + $d.top.c 
5
Because you can’t simply assign to elements in an 
XML
document, we’ll dig a little 
deeper into the 
[xml]
object and show how you can add elements.
.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 reorder pages; reorder pages in pdf
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; move pdf pages in preview
XML 
STRUCTURED
TEXT
PROCESSING
695
16.4.2
Adding elements to an XML object
Let’s add an element 
d
to this document. To do so, you need to use the methods on 
the 
XML
document object. First, you have to create the new element:
PS (10) > $el= $d.CreateElement("d")
In text, what you’ve created looks like 
<d></d>
. The tags are there, but they’re empty. 
Let’s set the element text, the “inner text,” to a value and then show the element:
PS (11) > $el.set_InnerText("Hello")
#text 
-----
Hello
Notice that you’re using the property setter method here. This is because the 
XML 
adapter hides the basic properties on the 
XmlNode
object. The other way to set this 
would be to use the 
PSBase
member as you did with the hashtable example earlier in 
this chapter:
PS (12) > $ne = $d.CreateElement("e")
PS (13) > $ne.InnerText = "World"
PS (14) > $d.top.AppendChild($ne)
#text 
-----
World
Take a look at the revised object:
PS (15) > $d.top
a : one
b : two
c : 3
d : Hello
e : World
The document now has five members instead of the original three. But what does the 
string look like? It’d be great if you could simply cast the document back to a string 
and see what it looks like:
PS (16) > [string] $d 
System.Xml.XmlDocument
Unfortunately, as you can see, it isn’t that simple. Instead, save the document as a file 
and display it:
PS (17) > $d.save("c:\temp\new.xml")
PS (18) > type c:\temp\new.xml 
<top>
<a>one</a>
<b>two</b>
<c>3</c>
696
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
<d>Hello</d>
<e>World</e> 
</top>
The result is a nicely readable text file. Now that you know how to add children to a 
node, how can you add attributes? The pattern is basically the same as with elements. 
First, create an attribute object:
PS (19) > $attr = $d.CreateAttribute("BuiltBy")
Next, set the value of the text for that object:
PS (20) > $attr.Value = "Windows PowerShell"
And finally add it to the top-level document:
PS (21) > $d.DocumentElement.SetAttributeNode($attr)
#text 
-----
Windows PowerShell
Let’s look at the top node once again:
PS (22) > $d.top
BuiltBy : Windows PowerShell 
      : one 
      : two 
      : 3 
      : Hello 
      : World
The attribute has been added.
XML and formatting
Although PowerShell’s XML support is good, there are some issues. The PowerShell 
formatting code has a bug: trying to display an XML node that has multiple children 
with the same name causes an error to be generated by the formatter. For example, 
the statement
[xml] $x =
"<root><item>1</item><item>2</item></root>";  $x.Root
will  result  in  an  error.  This  can  be  annoying  when  you’re  trying  to  explore  a 
document. By accessing the Item property on the Root node as follows
[xml] $x =
"<root><item>1</item><item>2</item></root>" ; $x.Root.Item
you’ll be able to see the elements without error. Also, for experienced .NET XML 
and XPath users, there are times when the XML adapter hides properties on an Xml-
XML 
STRUCTURED
TEXT
PROCESSING
697
It’s time to save the document:
PS (23) > $d.save("c:\temp\new.xml")
Then retrieve the file. You can see how the attribute has been added to the top node 
in the document:
PS (24) > type c:\temp\new.xml 
<top BuiltBy="Windows PowerShell">
<a>one</a>
<b>two</b>
<c>3</c>
<d>Hello</d> 
</top>
You’ve constructed, edited, and saved 
XML
documents, but you haven’t loaded an 
existing document yet, so that’s the next step.
16.4.3
Loading and saving XML files
At the end of the previous section, you saved an 
XML
document to a file:
PS (1) > $nd = [xml] (Get-Content -Read 10kb c:\temp\new.xml)
Here’s what you’re doing with this code. You use the 
Get-Content
cmdlet to read the 
file using a large read-count size. When you have the text, you cast the whole thing 
into an 
XML
document.
TIP
By default, 
Get-Content
reads one record at a time. This process 
can be  quite  slow.  When processing large  files, you should use the 
-ReadCount
parameter to specify a block size of –1. Doing so will 
cause the entire file to be loaded and processed at once, which is much 
faster.  Alternatively,  here’s another way  to  load an 
XML
document 
using the .
NET
methods:
$nd = [xml]"<root></root>" ).Load("C:\temp\new.xml")
Note that this does require that the full path to the file be specified.
(continued)
Document or XmlNode object that the .NET programmer expects to find. In these 
scenarios, the PSBase property is the workaround that lets you access the raw .NET 
object.
Finally, some XPath users may get confused by PowerShell’s use of the property 
operator . to navigate an XML document. XPath uses / instead. Despite these 
issues, for the nonexpert user or for “quick and dirty” scenarios, the XML adapter 
provides significant benefit in terms of reducing the complexity of working with 
XML.
698
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
Let’s verify that the document was read properly by dumping out the top-level node 
and then the child nodes:
PS (2) > $nd
top 
---
top
PS (3) > $nd.top
BuiltBy : Windows PowerShell 
      : one 
      : two 
      : 3 
      : Hello
All is as it should be. Even the attribute is there.
Although this is a simple approach and the one you’ll probably use most often, it’s 
not necessarily the most efficient approach because it requires loading the entire doc-
ument into memory. For very large documents or collections of many documents, 
loading all the text into memory may become a problem. In the next section, we’ll look 
at some alternative approaches that, though more complex, are more memory efficient.
Using the XmlReader class
Our previously discussed method for loading an 
XML
file is simple but not especially 
efficient. It requires that you load the file into memory, make a copy of the file while 
turning it into a single string, and create an 
XML
document representing the entire file 
using the 
XML
Document Object Model 
(DOM)
representation. The 
DOM
is what 
allows you to treat an 
XML
document as a hierarchy of objects, but to do so it con-
sumes a lot of memory. A much more space-efficient way to process 
XML
documents 
is to use the 
System.Xml.XmlReader
class. This class streams through the document 
one element at a time instead of loading the whole thing into memory. You’ll write a 
function that will use the 
XML
reader to stream through a document and output it 
properly indented—an 
XML
pretty-printer, if you will. Here’s what you want the out-
put of this function to look like when it dumps its built-in default document:
PS (1) > Format-XmlDocument 
<top BuiltBy = "Windows PowerShell">
<a>
one
</a>
<b>
two
</b>
<c>
3
</c>
<d>
XML 
STRUCTURED
TEXT
PROCESSING
699
Hello
</d> 
</top>
Now let’s test our function on a more complex document where there are more attri-
butes and more nesting. The following listing shows how to create this document.
@' 
<top BuiltBy = "Windows PowerShell">
<a pronounced="eh">
one
</a>
<b pronounced="bee">
two
</b>
<c one="1" two="2" three="3">
<one>
1
</one>
<two>
2
</two>
<three>
3
</three>
</c>
<d>
Hello there world
</d> 
</top> 
'@ > c:\temp\fancy.xml
When you run the function in listing 16.3, you see
PS (2) > Format-XmlDocument  c:\temp\fancy.xml 
<top BuiltBy = "Windows PowerShell">
<a pronounced = "eh">
one
</a>
<b pronounced = "bee">
two
</b>
<c one = "1"two = "2"three = "3">
<one>
1
</one>
<two>
2
</two>
<three>
3
</three>
</c>
Listing 16.3    Creating the text XML document
Documents you may be interested
Documents you may be interested