c# pdf viewer itextsharp : Reorder pages in pdf application software utility azure windows wpf visual studio Windows%20Powershell%20in%20Action%202nd%20Edition71-part1529

680
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
16.2.3
All together now—reading and writing
Our next topic involves combining reading and writing operations with binary files. 
First, you’ll set up paths to two files: a source bitmap file
$src = "$env:windir/Soap Bubbles.bmp"
and a destination in a temporary file:
$dest = "$env:temp/new_bitmap.bmp"
Next, copy the contents from one file to the other:
Get-Content -Encoding byte -read 10kb $src |
Set-Content -Encoding byte $dest
Now let’s define a (not very good) checksum function that simply adds up all the 
bytes in the file:
function Get-CheckSum ($path) 
{
$sum=0
Get-Content -Encoding byte -read 10kb $path | %{
foreach ($byte in $_) { $sum += $byte }
}
$sum 
}
Use this function to verify that the file you copied is the same as the original file (note 
that this is a fairly slow function and takes awhile to run):
PS (5) > Get-CheckSum $src 
268589 
PS (6) > Get-CheckSum $dest 
268589
The numbers come out the same, so you have some confidence that the copied file 
matches the original.
16.2.4
Performance caveats with Get-Content
PowerShell makes file processing easy, but the pipeline processor (at least as of version
2) is rather slow and this makes certain types of processing on large files problematic. 
For example, a user at Microsoft had a script that processed a large file to remove the 
first three lines from the file. This was done by using the following series of steps:
$lines = Get-Content $file -ReadCount 0 
$lines = $lines | select -Skip 3 
$lines | Set-Content temp.txt 
move temp.txt $file -Force
This script read in all the lines the file, used 
select
to skip the first three lines, wrote 
the result to a temporary file, and then did a forced rename to replace the original file. 
On the target file, this simple process was taking well over a minute due to pipeline 
processor overhead, and it had to be run on a very large number of files. Although
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
change pdf page order online; pdf change page order acrobat
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
reorder pdf pages in preview; rearrange pages in pdf online
P
ROCESSING
UNSTRUCTURED
TEXT
681
there  wasn’t  much  that  could  be  done  in  the  pipeline  to  speed  things  up,  a 
workaround was available: use the raw .
NET I/O
classes. The workaround looked 
something like this:
function Skip3 ($file, $encoding = [System.Text.Encoding]::Unicode) 
{
$input = Resolve-Path $file
$output = Join-Path (Split-Path -Parent $input) out.txt
[io.file]::WriteAllLines( $output,
[io.file]::ReadAllLines($input)[3..$text.length], $encoding) 
}
In this function, the .
NET
methods are used to read and write the file, and array index-
ing is used to strip of the first three lines. This script ran in less than a second for each 
file, making the intended task feasible. This type of workaround should be the excep-
tion rather than the rule. PowerShell is fast enough for most typical applications. It is 
nice, however, to know that faster techniques are available directly from PowerShell (at 
the cost of some complexity) instead of having to switch to a different tool.
This wraps up our coverage of the file system provider. In the next section we’ll 
look another useful provider: the Registry provider.
16.3
P
ROCESSING
UNSTRUCTURED
TEXT
Although PowerShell is an object-based shell, it still has to deal with text. In chapter 
4, we covered the operators (
-match
-replace
-like
-split
-join
) that Power-
Shell provides for working with text. We showed you how to concatenate two strings 
together  using  the  plus  operator.  In  this  section,  we’ll  cover  some  of  the  more 
advanced string processing operations. We’ll discuss techniques for splitting and join-
ing strings using the 
[string]
and 
[regex]
members and using filters to extract sta-
tistical information from a body of text.
16.3.1
Using System.String to work with text
One common scenario for scripting is processing log files. This requires breaking the 
log strings into pieces to extract relevant bits of information. PowerShell v2 address 
this by using the 
-split
operator, but in PowerShell v1, if you needed to split a 
string into pieces, you had to use the 
Split()
method on the 
[string] 
class. This is 
still fairly simple to do:
PS (1) > "Hello there world".Split() 
Hello 
there 
world
The 
Split()
method with no arguments splits on spaces. In this example, it pro-
duces an array of three elements.
PS (2) > "Hello there world".Split().length 
3
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.
switch page order pdf; move pages in pdf reader
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 pages in pdf file; reorder pages in pdf online
682
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
You can verify this with the 
Length
property. In fact, it splits on any of the characters 
that fall into the 
WhiteSpace
character class. This includes tabs, so it works properly 
on a string containing both tabs and spaces:
PS (3) > "Hello`there world".Split() 
Hello 
there 
world
In the revised example, you still get three fields, even though space is used in one 
place and tab in another.
And while the default is to split on a whitespace character, you can specify a string 
of characters to use split fields:
PS (4) > "First,Second;Third".Split(',;') 
First 
Second 
Third
Here you specified the comma and the semicolon as valid characters to split the field.
There is, however, an issue; the default behavior for “split this” isn’t necessarily 
what you want. The reason why is that it splits on each separator character. This 
means that if you have multiple spaces between words in a string, you’ll get multiple 
empty elements in the result array. For example:
PS (5) > "Hello there    world".Split().length 
6
In this example, you end up with six elements in the array because there are three 
spaces between “there” and “world.” Now let’s continue on paralleling the features of 
the 
-split
operator.
Using SplitStringOptions
The 
-split
operator allows you to specify a number of options that are used to con-
trol the splitting process. Let’s see how you can do the same thing using the 
Split() 
method. You can get a list of all of the method overloads by using the 
Overload-
Definitions
member on the 
PSMethod
object for 
Split
:
PS (6) > "hello".split.OverloadDefinitions 
string[] Split(Params char[] separator) 
string[] Split(char[] separator, int count) 
string[] Split(char[] separator, System.StringSplitOptions options) 
string[] Split(char[] separator, int count, System.StringSplitOptions
options) 
string[] Split(string[] separator, System.StringSplitOptions options) 
string[] Split(string[] separator, int count, System.StringSplitOptio 
ns options)
The methods that take the 
options
argument look promising. Let’s see what the 
SplitStringOptions
are. Do so by trying to cast a string into these options:
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 move pages within a pdf document; how to reorder pages in pdf reader
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 a pdf file; moving pages in pdf
P
ROCESSING
UNSTRUCTURED
TEXT
683
PS (8) > [StringSplitOptions] "abc"
Cannot convert value "abc" to type "System.StringSplitOptions" 
due to invalid enumeration values. Specify one of the following 
enumeration values and try again. The possible enumeration values
are "None, RemoveEmptyEntries". 
At line:1 char:21 
+ [StringSplitOptions]  <<<< "abc"
The error message tells you the legitimate values for the enumeration. If you look up 
this class in the online documentation on 
MSDN
, you’ll see that this option tells the 
Split()
method to discard empty array elements. This sounds just like what you 
need, so let’s try it:
PS (9) > "Hello there    world".split(" ", 
>> [StringSplitOptions]::RemoveEmptyEntries) 
>>
Hello 
there 
world
It works as desired. Next you can apply this technique to a larger problem.
Analyzing word use in a document
Given a body of text, say you want to find the number of words in the text as well as 
the number of unique words and then display the 10 most common words in the 
text.  For  our  purposes,  we’ll  use  one  of  the  PowerShell  help  text  files:  about_ 
Assignment_operators.help.txt. This isn’t a particularly large file (about 17 
KB
) so 
you can load it into memory using the 
Get-Content
(
gc
) cmdlet:
PS (10) > $s = gc $PSHOME/en-US/about_Assignment_operators.help.txt 
PS (11) > $s.length 
747
The variable 
$s
now contains the text of the file as a collection of lines (747 lines, to 
be exact). This is usually what you want, because it lets you process a file one line at 
time. But, in this example, you actually want to process this file as a single string. To 
do so, you could use the 
-join
operator, but let’s use the 
String.Join()
method 
instead. You’ll join all of the lines, adding an additional space between each line:
PS (12) > $s = [string]::join(" ", $s) 
PS (13) > $s.length 
22010
Now 
$s
contains a single string containing the whole text of the file. You verify this 
by checking the length rather than displaying it. Next, split it into an array of words:
PS (14) > $words = $s.Split(" `t", 
>> [stringsplitoptions]::RemoveEmptyEntries) 
>>
PS (15) > $words.length 
3316
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
change pdf page order reader; move pdf pages in preview
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 reverse page order; how to move pages around in pdf
684
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
So the text of the file has 3,316 words in it. You need to find out how many unique 
words there are. You have a couple ways of doing this. The easiest approach is to use 
the 
Sort-Object
cmdlet with the 
-Unique
parameter. This code will sort the list of 
words and then remove all the duplicates:
PS (16) > $uniq = $words | sort -Unique 
PS (17) > $uniq.count 
604
The help topic contains 604 unique words. Using the 
Sort-Object
cmdlet is fast 
and simple, but it doesn’t cover everything you wanted to do, because it doesn’t give 
the frequency of use. Let’s look at another approach: using the 
ForEach-Object 
cmdlet and a hash table.
16.3.2
Using hashtables to count unique words
In the previous example, you used the 
-Unique
parameter on 
Sort-Object
to gener-
ate a list of unique words. Now you’ll take  advantage of the set-like behavior of 
hashtables to do the same thing, but in addition you’ll be able to count the number of 
occurrences of each word.
NOTE
In mathematics, a set is a collection of unique elements. This is 
how the  keys work in a  hashtable.  Each key  in  a hashtable  occurs 
exactly once. Attempting to add a key more than once will result in an 
error. In PowerShell, assigning a new value to an existing key replaces 
the old value associated with that key. The key itself remains unique. 
This turns out to be a powerful technique, because it’s a way of build-
ing index tables for collections of objects based on arbitrary property 
values.  These  index  tables  let  you  run  database-like  operations  on 
object collections. See appendix B for an example of how you can use 
this technique to implement a SQL-like join operation on two collec-
tions of objects.
Once again, you split the document into a stream of words. Each word in the stream 
will be used as the hashtable key, and you’ll keep the count of the words in the value. 
Here’s the script:
PS (18) > $words | % {$h=@{}} {$h[$_] += 1}
It’s  not  much  longer  than  the  previous  example.  The  code  uses  the 
%
alias for 
ForEach-Object
to keep it short. In the 
begin
clause in 
ForEach-Object
, you’re 
initializing the variable 
$h
to hold the resulting hashtable. Then, in the process script-
block, you increment the hashtable entry indexed by the word. You’re taking advan-
tage  of the way  arithmetic works in  PowerShell.  If the key doesn’t exist yet, the 
hashtable returns 
$null
. When 
$null
is added to a number, it’s treated as 0. This 
allows the expression
$h[$_] += 1
.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.
how to reorder pdf pages in; how to move pdf pages around
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
rearrange pages in pdf document; rearrange pdf pages online
P
ROCESSING
UNSTRUCTURED
TEXT
685
to work. Initially, the hashtable member for a given key doesn’t exist. The 
+=
operator 
retrieves 
$null
from the table, converts it to 0, adds 1, and then assigns the value 
back to the hashtable entry.
Let’s verify that the script produces the same answer for the number of words as 
you found with the 
Sort-Object -Unique
solution:
PS (19) > $h.keys.count 
604
You have 604, the same as before.
Now you have a hashtable containing the unique words and the number of times 
each word is used. But hashtables aren’t stored in any particular order, so you need to 
sort it. You’ll use a scriptblock parameter to specify the sorting criteria. Tell it to sort 
the list of keys based on the frequency stored in the hashtable entry for that key:
PS (20) > $frequency = $h.keys | sort {$h[$_]}
The words in the sorted list are ordered from least frequent to most frequent. This 
means that 
$frequency[0]
contains the least frequently used word:
PS (21) > $frequency[0] 
avoid
The last entry in frequency contains the most commonly used word. If you remem-
ber from chapter 3, you can use negative indexing to get the last element of the list:
PS (22) > $frequency[-1] 
the
It comes as no surprise that the most frequent word is “the,” and it’s used 344 times:
PS (23) > $h["The"] 
344
The next most frequent word is “to,” which is used 138 times:
PS (24) > $h[$frequency[-2]] 
138 
PS (25) > $frequency[-2] 
to
Here are the top 10 most frequently used words in the 
about_Assignment_opera-
tors
help text:
PS (26) > -1..-10 | %{ $frequency[$_]+" "+$h[$frequency[$_]]} 
the 344 
to 138 
a 124 
$a 116 
value 102 
C:\PS> 85 
of 80
686
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
= 74 
variable 57 
Operator 53
PowerShell includes a cmdlet that’s also useful for this kind of task: 
Group-Object
This cmdlet groups its input objects into collections sorted by the specified property. 
This means that you can achieve the same type of ordering with the following:
PS (27) > $grouped = $words | group | sort count
Once again, you see that the most frequently used word is “the”:
PS (28) > $grouped[-1]
Count Name                      Group 
----- ----                      -----
344 the                       {the, the, the, the...}
You can display the 10 most frequent words with this:
PS (29) > $grouped[-1..-10]
Count Name                      Group 
----- ----                      -----
344 the                       {the, the, the, the...}
138 to                        {to, to, to, to...}
124 a                         {a, a, a, a...}
116 $a                        {$a, $a, $a, $a...}
102 value                     {value, value, value, value...}
85 C:\PS>                    {C:\PS>, C:\PS>, C:\PS>, C:\PS>...}
80 of                        {of, of, of, of...}
74 =                         {=, =, =, =...}
57 variable                  {variable, variable, variable, var...
53 Operator                  {Operator, operator, operator, ope...  
The code creates a nicely formatted display courtesy of the formatting and output 
subsystem built into PowerShell.
In  this  section,  you  learned  how  to  split  strings  using  the  methods  on  the 
[string]
class. You even saw how to split strings on a sequence of characters. But in 
the world of unstructured text, you’ll quickly run into examples where simple splits 
aren’t enough. As is so often the case, regular expressions come to the rescue. In the 
next couple of sections, you’ll see how you can do more sophisticated string process-
ing using the 
[regex]
class.
16.3.3
Using regular expressions to manipulate text
In the previous section, we looked at basic string processing using members on the 
[string]
class. Although this class offers a lot of potential, there are times when you 
need to use more powerful tools. This is where regular expressions come in. As we 
discussed in chapter 4, regular expressions are a domain-specific language 
(DSL)
for 
matching and manipulating text. We covered a number of examples using regular
P
ROCESSING
UNSTRUCTURED
TEXT
687
expressions with the 
-match
and 
-replace
operators. This time, you’re going to 
work with the regular expression class itself.
Splitting strings with regular expressions
As mentioned in chapter 3, there’s a type accelerator, 
[regex]
, for the regular expres-
sion type. The 
[regex]
type also has a 
Split()
method, but it’s much more power-
ful because it uses a regular expression to decide where to split strings instead of a 
single character:
PS (1) > $s = "Hello-1-there-22-World!"
PS (2) > [regex]::split($s,'-[0-9]+-') 
Hello 
there 
World!
PS (3) > [regex]::split($s,'-[0-9]+-').count 
3
In this example, the fields are separated by a sequence of digits bound on either side 
by  a  dash.  This  pattern  couldn’t  be  specified  with  simple  character-based  split 
operations.
When working with the .
NET
regular expression library, the 
[regex]
class isn’t 
the only class that you’ll run into. You’ll see this in the next example, when we look 
at using regular expressions to tokenize a string.
Tokenizing text with regular expressions
Tokenization, or the process of breaking a body of text into a stream of individual 
symbols, is a common activity in text processing. In chapter 2 we talked a lot about 
how the PowerShell interpreter has to tokenize a script before it can be executed, and 
you saw this in action in chapters 14 and 15. In the next example, we’re going to look 
at how you can write a simple tokenizer for basic arithmetic expressions you might 
find in a programming language. First, you need to define the valid tokens in these 
expressions. You want to allow numbers made up of one or more digits; allow num-
bers made up of any of the operators +, -, *, or /; and also allow sequences of spaces. 
Here’s what the regular expression to match these elements looks like:
PS (4) > $pat = [regex] "[0-9]+|\+|\-|\*|/| +"
This is a pretty simple pattern using only the alternation operator | and the quantifier 
+, which matches one or more instances. Because you used the 
[regex]
cast in the 
assignment, 
$pat
contains a regular expression object. You can use this object directly 
against an input string by calling its 
Match()
method:
PS (5) > $m = $pat.match("11+2 * 35 -4")
The 
Match()
method returns a 
Match
object (the full type name is 
Sys-
tem.Text.RegularExpressions.Match
). You can use the 
Get-Member
cmdlet to
688
CHAPTER 16
W
ORKING
WITH
FILES
TEXT
AND
XML
explore the full set of members on this object at your  leisure, but for now we’re 
interested in only three members. The first member is the 
Success
property. This 
will be true if the pattern matched. The second interesting member is the 
Value 
property, which will contain the matched value. The final member we’re interested in 
is the 
NextMatch()
method. Calling this method will step the regular expression 
engine to the next match in the string, and is the key to tokenizing an entire expres-
sion. You can use this method in a 
while
loop to extract the tokens from the source 
string one at a time. In the example, you keep looping as long the 
Match
object’s 
Success
property is true. Then you display the 
Value
property and call 
Next-
Match()
to step to the next token:
PS (6) > while ($m.Success) 
>> { 
>>     $m.value 
>>     $m = $m.NextMatch() 
>> } 
>> 
11 
2
*
35
-
4
In the output, you see each token, one per line in the order in which they appeared in 
the original string.
You now have a powerful collection of techniques for processing strings. The next 
step is to apply these techniques to processing files. Of course, you also need to spend 
some time  finding,  reading, writing, and copying files. In the next  section, we’ll 
review the basic file abstractions in PowerShell and then look at file processing.
16.3.4
Searching files with the Select-String cmdlet
You encountered the 
Select-String
cmdlet earlier, but we haven’t looked at it in 
great detail. We’ll fix that in this section.
The 
Select-String
cmdlet allows you to search through collections of strings 
or collections of files. It’s similar to the 
grep
command on 
UNIX
-derived systems 
and the 
findstr
command on Windows. Figure 16.2 shows the parameters on this 
cmdlet.
You might ask why this cmdlet is needed—doesn’t the base language do every-
thing it does? The answer is yes, but searching through files is such a common opera-
tion that having a cmdlet optimized for this purpose makes sense. Let’s look at some
P
ROCESSING
UNSTRUCTURED
TEXT
689
examples. First, you’ll search through all of the “about_*” topics in the PowerShell 
installation directory to see if the phrase “wildcard description” is there:
PS (1) > Select-String "wildcard description" $pshome/en-US/about*.txt
C:\Windows\System32\WindowsPowerShell\v1.0\en-US\about_wildcards.help 
.txt:42:        Wildcard Description        Example  Match
No match
You see that there’s exactly one match, but notice the uppercase letters in the match-
ing string. Now rerun the search using the 
-CaseSensitive
parameter:
PS (2) > Select-String -case "wildcard description" ` 
>> $pshome/en-US/about*.txt 
>>
This time nothing was found. If you alter the case in the pattern to match the target 
string, then it works again:
PS (3) > Select-String -case "Wildcard Description" ` 
>> $pshome/en-US/about*.txt 
>>
C:\Windows\System32\WindowsPowerShell\v1.0\en-US\about_wildcards.help 
.txt:42:        Wildcard Description        Example  Match
No match
Select-String [-Pattern] <String[]> 
-InputObject <PSObject>
[-Path] <String[]>
[-AllMatches]
[-CaseSensitive] 
[-Context <Int32[]>]
[-Encoding <String>]
[-Exclude <WildcardPattern[]>]
[-Include <WildcardPattern[]>]
[-List] 
[-NotMatch] 
[-SimpleMatch] 
[-Quiet] 
Cmdlet name
Pattern to search for
If specified, search 
case-sensitively
Return true if at least one match
in file or string being searched
Use simple string match
instead of regular expression 
when searching
Search for files or strings
(only one can be specified)
Include all matches
in line in result
object Matches 
property (v2 only)
Include lines around
match in output (v2 only)
Character encoding
scheme to use; required
only if correct encoding isn’t
auto-detected (v2 only)
Only return first
match in file
Return items that weren’t
matched (v2 only)
Filter collection of files
to search using
wildcards to select files 
to include or exclude 
Figure 16.2 The 
Select-String
cmdlet is a powerful tool for extracting information from 
unstructured text. Parameters marked “v2 only” were introduced in PowerShell v2.
Documents you may be interested
Documents you may be interested