c# pdf viewer free : Change page order in pdf online Library SDK component .net asp.net azure mvc Windows%20Powershell%20in%20Action%202nd%20Edition17-part1469

140
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
The unary form of the 
-join
operator allows you to concatenate a collections of 
strings into a single string with no separator between each item in the resulting string. 
Here’s a simple example. First assign an array of numbers to the variable 
$in
:
PS {1) > $in = 1,2,3
Now check the type of the variable’s value
PS {2) > $in.GetType().FullName 
System.Object[]
and you see that it’s an array of objects. (Remember that PowerShell arrays are always 
created as polymorphic arrays, regardless of the content of the arrays.) Now use the 
-join
operator on this variable and assign the result to a new variable, 
$out
:
PS {3) > $out = -join $in
Checking the type of the result
PS {4) > $out.GetType().FullName 
System.String
you see that it’s a string. The 
-join
operator first converted each array element into a 
string and then joined the results into a single larger string. Let’s look at the contents 
of 
$out
to see what the result looks like:
PS {5) > $out 
123
It’s “123”, as expected. Next, let’s do something a bit more sophisticated. Say you 
want to reverse a  string. Unfortunately the .
NET
[string]
type has no built-in 
reverse operator, but the 
[array]
type does have a static method for reversing arrays. 
This method takes an array as input and sorts it in place. To use this, you need to do 
two conversions: from a string to an array of characters and from an array of charac-
ters back to a string. From chapter 3, you know that you can use a cast to convert a 
string into a character array:
PS {6) > $ca = [char[]] "abcd"
Now that you have a character array, you can use the 
Reverse()
method. 
PS {7) > [array]::Reverse($ca)
This method reverses the contents of the array in-place so when you look at the 
result, you see that it’s reversed as desired. But it’s still an array of characters and you 
need a string:
PS {8) > $ca 
a
Change page order in pdf online - 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 change page order in pdf document; change pdf page order preview
Change page order in pdf online - 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; move pages in pdf acrobat
P
ATTERN
MATCHING
AND
TEXT
MANIPULATION
141
This is where the unary 
-join
comes into play. Use it to convert the character array 
back into a string:
PS {9) > $ra = -join $ca
And verify that the string has been created properly:
PS {10) > $ra 
dcba
Yes, it has. Now let’s look at one potential gotcha using the unary form of the opera-
tor. Let’s redo the join of 1,2,3 again, but without using a variable to hold the value. 
Here’s what that looks like:
PS {11) > -join 1,2,3 
3
Surprise! Instead of joining the array members into a single string, it just returned the 
same array. This is because unary operators have higher precedence than binary oper-
ators and, in PowerShell, the comma is a binary operator. As a result, the expression is 
parsed like
PS {12) > (-join 1),2,3 
3
So, to use the unary 
-join
operator in a more complex expression, make sure you 
put parentheses around the argument expression:
PS {13) > -join (1,2,3) 
123
When parentheses are used, the result of the expression is as expected. Next let’s look 
at the (much more useful) binary form.
The binary form for the 
-join
operator is shown in figure 4.11.
The obvious difference with this operator is that you can specify the string to use
as an element separator instead of always using the default of nothing between the 
joined strings. Let’s execute the example from the figure. Place the array to join into a 
variable called 
$numbers
and put the joined result into a variable called 
$exp
:
PS {1) > $numbers = 1,2,3 
PS {2) > $exp = $numbers -join '+'
1,2,3 -join "+"
Join operator
Collection to join
String to join with
Figure 4.11 The binary form of the 
-join
operator allows you to join a 
collection of objects into a single string 
using the specified join string.
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. C# File: Split PDF; C# Page: Insert PDF pages; C#
reverse page order pdf; how to reorder pages in pdf file
VB.NET Word: Change Word Page Order & Sort Word Document Pages
Note: if you are trying to change the order of a you want to see other VB.NET Word document editing controls, please read this Word reading page which has
how to move pages within a pdf; reorder pages pdf file
142
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
Look at the contents of 
$exp
:
PS {3) > $exp 
1+2+3
It contains the numbers with a plus sign between each number. Because this is a valid 
PowerShell expression, you can pass the resulting string to the 
Invoke-Expression 
cmdlet for evaluation:
PS {4) > Invoke-Expression $exp 
6
The result is 6. Of course, this works on any operator. Let’s use the range operator 
(see chapter 5) and the multiply operator to calculate the factorial of 10. Here’s what 
the code looks like:
PS {5) > $fact = Invoke-Expression (1..10 -join '*')
This code is evaluating 
1*2*3
and so on up to 10, with the result
PS {6) > $fact 
3628800
Although this is a simple way to calculate factorials, it’s not efficient. Later on you’ll 
see more efficient ways of writing this type of expression. For now, let’s look at a more 
practical example and do some work with a file. Let’s use a here-string to generate a 
test file on disk:
PS {7) > @' 
>> line1 
>> line2 
>> line3 
>> '@ > out.txt 
>>
Now use the 
Get-Content
cmdlet to read that file into a variable, 
$text
:
PS {8) > $text = Get-Content out.txt
Use the 
text
property to see how long the file was:
PS {9) > $text.Count 
3
Clearly this isn’t the number of characters in the file. It’s actually the number of lines 
in the file. The 
Get-Content
cmdlet returns the contents of a file as an array of 
strings. For example, to see the second line in the file, use this:
PS {10) > $text[1] 
line2
To check the type of the value in 
$text
, you can again use the 
GetType()
method:
PS {11) > $text.GetType().FullName 
System.Object[]
C# Word - Process Word Document in C#
For example, you may change your Word document order from 1, 2, 3, 4, 5 to 3, 5, 4, 2,1 with C# coding. C#.NET: Extracting Page(s) from Word.
switch page order pdf; reorder pages in pdf document
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
page from PDF file and changing the position, orientation and order of PDF PDF Page and File Splitting. If you want to split PDF file into two or small files
how to reverse page order in pdf; pdf reverse page order preview
P
ATTERN
MATCHING
AND
TEXT
MANIPULATION
143
As  you  can  see,  it’s  an 
[object]
array, which you should be used to by now. 
Although this is exactly what you want most of the time, sometimes you just want the 
entire file as a single string. The 
Get-Content
cmdlet, as of PowerShell v2, has no 
parameter for doing this, so you’ll have to take the array of strings and turn it back 
into a single string. You can do this with the binary 
-join
operator if you specify the 
line separator as the string to use when joining the array elements. On Windows, the 
line separator is two characters: carriage return (`r) and a line feed (`n). In a single 
string, this is expressed as “`r`n”. Now you can use this separator string in a 
-join 
expression:
PS {12) > $single = $text -join "`r`n" 
PS {13) > $single.Length 
19
That’s more like it. And when you check index zero
PS {14) > $single[0] 
l
you see that it’s now a single character instead of a string. 
Let’s see one more example, which shows how to generate a string containing 
comma-separated values—a CSV string:
PS {16) > $csv = -join ('"',($numbers -join '","'), '"') 
PS {17) > $csv 
"1","2","3"
PS {18) > 
You use 
-join
to insert the sequence 
","
between each element and then use string 
concatenation to add double quotes to either end. It’s a very simple one-line 
CSV 
generator.
Now that you know how to put things together, we’ll show you how to take them 
apart with 
-split
.
4.4.6
The -split operator
The 
-split
operator performs the opposite operation to 
-join
: it splits strings into 
a collection of smaller strings. Again, this operator can be used in both binary and 
unary forms. The unary form of split is shown in figure 4.12. 
In its unary form, this operator will split a string on whitespace boundaries, where 
whitespace is any number of spaces, tabs, or newlines. You saw this in an example 
earlier in this chapter.
The binary form of the operator 
is  much  more,  ahem,  sophisti-
cated. It allows you to specify the 
pattern  to  match  on,  the  type  of 
matching to do, and the number of 
elements to return, as well as match
Split operator
-split "a b c"
String to split
Figure 4.12 The unary 
-split
operator 
allows you to split a string into a collection 
of smaller strings.
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the position of certain one PowerPoint page in an
pdf reverse page order; pdf change page order online
C# Word - Sort Word Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several Word document pages, or just change the position of certain one Word page in an
rearrange pages in pdf online; rearrange pages in pdf reader
144
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
type-specific options. The full (and rather intimidating) syntax for this operator is 
shown in figure 4.13.
Although figure 4.13 looks intimidating, most of the time you just need to specify 
an argument string and split pattern and let the rest of the options use their default 
values. Let’s take a look at the basic application of this operator. First, split a string on 
a character other than whitespace:
PS {11) > 'a:b:c:d:e' -split ':' 
e
This is pretty straightforward. The string is split into five elements at the : character. 
But sometimes you don’t want all the matches. The 
-split
operator allows you to 
limit the number of elements to return. Do so by specifying an integer after the 
match pattern:
PS {12) > 'a:b:c:d:e' -split ':',3 
c:d:e
In this case, you only asked for three elements to be returned. Notice that the third 
piece is the entire remaining string. If you specify a split count number less than or 
equal to 0, then all the splits take place:
PS {13) > 'a:b:c:d:e' -split ':',0 
e
You’ll see why this is important in a minute.
By default, 
-split
uses regular expressions just like 
-match
and 
-replace
. But if 
the string you’re trying to split contains one of the many characters that have special 
meaning in regular expressions, things become a bit more difficult because you’ll have 
to escape these characters in the split pattern. This can be inconvenient and error
"a, b ,c" -split "\w*,\w*",n,MatchType,Options
Split operator
String to split
Maximum number
of substrings
Pattern to split
with
Match type
specific options
Type of matching
to use
Figure 4.13 The 
-split
operator allows you to split a 
string into a collection of 
smaller strings. It lets you 
specify a variety of argu-
ments and options to control 
how the target string is split.
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
Enable C#.NET developers to change the page order of source PDF document file; Allow C#.NET developers to add image to specified area of source PDF
change pdf page order; how to reverse pages in pdf
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via Change PDF original password. In order to run the sample code, the following steps would be
how to rearrange pages in a pdf reader; how to move pages within a pdf document
P
ATTERN
MATCHING
AND
TEXT
MANIPULATION
145
prone, so 
-split
allows you to choose simple matching through an option known as 
simplematch
. When you specify 
simplematch
, instead of treating the split pattern 
as a regular expression, it’s handled as a simple literal string that must be matched. 
For example, say you want to split on *:
PS {14) > 'a*b*c' -split "*"
Bad argument to operator '-split': parsing "*" - Quantifier
{x,y} following nothing..
At line:1 char:15 
+ 'a*b*c' -split <<<<  "*"
+ CategoryInfo          : InvalidOperation: (:) [],
RuntimeException
+ FullyQualifiedErrorId : BadOperatorArgument
This results in a regular expression parsing error. Now try it again with 
simplematch
:
PS {15) > 'a*b*c' -split "*",0,"simplematch" 
c
This time it worked properly. This option is particularly handy when you aren’t using 
literal split strings but instead are getting them from a script argument or input file. 
In those cases, it’s much simpler to use 
simplematch
instead of escaping all the spe-
cial regular expression characters.
-split operator options
The last element shown in the 
-split
operator syntax diagram (figure 4.7) is the 
match options string. These options are shown in table 4.9. Multiple options can be 
specified  in  a  string  with  commas  between  them,  like 
RegexMatch,Ignore-
Case,MultiLine
or 
SimpleMatch,IgnoreCase
.
Table 4.9 Match options for the -split operator
Option
Description
Applies to
IgnoreCase
Allows you to override default case-sensitive 
behavior when using the -csplit variant of 
the operator. 
RegexMatch, 
SimpleMatch
CultureInvariant
Disables any culture-specific matching behav-
ior (e.g., what constitutes uppercase)  when 
matching the separator strings.
RegexMatch
IgnorePatternWhitespace
Ignores unescaped whitespace and comments 
embedded in the pattern. This allows for com-
menting complex patterns.
RegexMatch
MultiLine
Treat a string as though it’s composed of multi-
ple lines. A line begins at a newline character 
and will be matched by the ^ pattern.
RegexMatch
146
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
We won’t cover all the options here. In practice, you aren’t likely to need most of 
them, but we’ll examine the ones that are typically useful, as well as some techniques 
for using them. The first one we’ll look at is the 
IgnoreCase
option. This option lets 
you change how case is handled when splitting the string. Normally this behavior is 
controlled by the name of the operator (case-sensitive for 
-csplit
and case-insensi-
tive for 
-split
or 
–isplit
). This is determined at parse time; then the script is 
transformed into an executable form. There are cases where you want to be able to 
override the parse time behavior at runtime. You can do this by using a variable to 
pass in the option instead of a constant string. Let’s see how this works. Start with a 
$opts
variable that contains an empty string:
PS {1) > $opts = ''
Now pass this in the options position for the operator:
PS {2) > 'axbXcxdXe' -csplit 'x',0, $opts 
bXc 
dXe
Because the option variable, 
$opts
, was empty, you get the expected behavior: the 
split is done in the case-sensitive manner as determined by 
-csplit
. Assign 
ignore-
case
to the variable, and try it again:
PS {3) > $opts = 'ignorecase'
PS {4) > 'axbXcxdXe' -csplit 'x',0, $opts 
e
This time the string splits on all instances of 
x
regardless of case, even though the 
-csplit
operator was used. This shows how the parse-time defaults can be overrid-
den at runtime.
SingleLine
This option, which is the default, tells the pat-
tern matcher to treat the entire string as a sin-
gle line. Newlines in the string aren’t 
considered the beginning of a line.
RegexMatch
ExplicitCapture
This option specifies that the only valid cap-
tures are explicitly named or numbered ones of 
the form (?<name>…). This allows unnamed 
parentheses to act as noncapturing groups 
without the syntactic clumsiness of the 
expression (?:…). See section 4.4.3 earlier in 
this chapter on how captures work. 
RegexMatch
Table 4.9 Match options for the -split operator (continued)
Option
Description
Applies to
P
ATTERN
MATCHING
AND
TEXT
MANIPULATION
147
The next option we want to look at is the 
multiline
option. This option can 
only be used with regular expression matches and changes what the pattern matcher 
considers the beginning of the string. In regular  expressions,  you can  match the 
beginning of a line with the 
^
metacharacter. In the default 
singleline
mode, the 
beginning of the line is the beginning of the string. Any newlines in the string aren’t 
treated as the beginning of a line. When you use the 
multiline
option, embedded 
newlines are treated as the beginning of a line. Here’s an example. First you need 
some text to split—let’s use a here-string to put this text into the 
$text
variable:
PS {5) > $text = @' 
>> 1 
>> aaaaaaa 
>> aaaaaaa 
>> 2 
>> bbbbbbb 
>> 3 
>> ccccccc 
>> ccccccc 
>> 4 
>> ddddddd 
>> '@ 
>>
In the example text, each section of the document is numbered. You want to split 
these “chapters” into elements in an array, so 
$a[1]
is chapter 1, $
a[2]
is chapter 2, 
and so on. The pattern you’re using (
^\d
) will match lines that begin with a number. 
Now use this pattern to split the document in 
multiline
mode, assigning the result 
to 
$a
PS {6) > $a = $text -split '^\d', 0, "multiline"
If all went as planned, 
$a
should now contain four elements: 
PS {7) > $a.Length 
5
Wait a minute—the result is 5! But there were only four sections! There are actually 
five sections because the empty text before the 1 gets its own chapter. Now let’s look 
at chapter 1, which should be in 
$a[1]
PS {8) > $a[1]
aaaaaaa 
aaaaaaa
and chapter 2 in 
$a[2]
:
PS {9) > $a[2]
bbbbbbb
PS {10) >
148
CHAPTER 4
O
PERATORS
AND
EXPRESSIONS
As you can see, the 
multiline
option with regular expressions allows for some pretty 
slick text processing. 
Using scriptblocks with the -split operator
As powerful as regular expressions are, sometimes you may need to split a string in a 
way that isn’t convenient or easy to handle with regular expressions. To deal with 
these cases, PowerShell allows you to pass a scriptblock to the operator. The script-
block is used as a predicate function that determines whether there’s a match. Here’s an 
example. First set up a string to split. This string contains a list of colors that you 
want to split into pairs, two colors per pair:
PS {17) > $colors = "Black,Brown,Red,Orange,Yellow," + 
>> "Green,Blue,Violet,Gray,White'"
Next initialize a counter variable that will be used by the scriptblock. You’re using an 
array  here because  you  need  to be  able to  modify  the contents  of  this variable. 
Because the scriptblock is executed in its own scope, you must pass it an array so it 
can modify the value:
PS {18) > $count=@(0)
And now split the string. The scriptblock, in braces in the example, splits the string 
on every other comma:
PS {19) > $colors -split {$_ -eq "," -and ++$count[0] % 2 -eq 0 } 
Black,Brown 
Red,Orange 
Yellow,Green 
Blue,Violet 
Gray,White'
This gives you the color pairs you were looking for.
Whew! So that’s it for the pattern-matching and text-manipulation operators. In 
this section, we covered the two types of pattern-matching operators—wildcard pat-
terns and regular expressions. Wildcard patterns are pretty simple, but learning to use 
regular expressions effectively requires more work. On the other hand, you’ll find 
that the power of regular expressions is more than worth the effort invested to learn 
them. (We’ll come back to these patterns again in chapter 6 when we discuss the 
switch
statement.) We also looked at how to split strings into collections and join 
collections into strings. All very spiffy, but let’s come back down to Earth now and 
cover the last of the basic operators in the PowerShell language. These are the logical 
operators (
-and
-or
-not
) and their bitwise equivalents (
-band
-bor
-bnot
).
4.5
L
OGICAL
AND
BITWISE
OPERATORS
Finally, PowerShell has logical operators 
-and
-or
-xor
, and 
-not
for combining 
simpler comparisons into more complex expressions. The logical operators convert 
their operands into Boolean values and then perform the logical operation. 
L
OGICAL
AND
BITWISE
OPERATORS
149
PowerShell also provides corresponding bitwise operators for doing binary operations 
on integer values. These operators can be used to test and mask bit fields. Both of 
these sets of operators are shown in figure 4.14.
Table 4.10 lists these operators with examples showing how each of these opera-
tors can be used.
As with most languages based on 
C/C
++, the PowerShell logical operators are short-
circuit operators—they only do as much work as they need to. With the 
-and
opera-
tor, if the left operand evaluates to 
$false
, then the right operand expression isn’t 
executed. With the 
-or
operator, if the left operand evaluates to 
$true
, then the 
right operand isn’t evaluated.
NOTE
In PowerShell v1, the bitwise operators were limited in that 
they only supported 32-bit integers (
[int]
). In v2, support was added 
for 64-bit  integers  (
[long]
). If the arguments  to  the operators  are
Table 4.10 Logical and bitwise operators
Operator
Description
Example
Result
-and
Do a logical and of the left and right 
values.
0xff -and $false
$false
-or
Do a logical or of the left and right 
values.
$false –or 0x55
$true
-xor
Do a logical exclusive-or of the left and 
right values.
$false –xor $true 
$true –xor $true
$true
$false
-not
Do the logical complement of the 
argument value.
-not $true
$false
-band
Do a binary and of the bits in the values 
on the left and right side.
0xff –band 0x55
85 (0x55)
-bor
Do a binary or of the bits in the values 
on the left and right side.
0x55 -bor 0xaa
255 (0xff)
-bxor
Do a binary exclusive-or of the left and 
right values.
0x55 -bxor 0xaa 
0x55 -bxor 0xa5
255 (0xff) 
240 (0xf0)
-bnot
Do the bitwise complement of the 
argument value.
-bnot 0xff
-256 
(0x ffffff00)
-band     -bor     -bnot    -bxor
Bitwise operators
-and     -or     -not     -xor
Logical operators
Figure 4.14 The logical and bitwise 
operators available in PowerShell
Documents you may be interested
Documents you may be interested