c# pdf viewer free : How to move pages around in pdf SDK Library service wpf .net winforms dnn Windows%20Powershell%20in%20Action%202nd%20Edition24-part1477

210
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
the loop enumerator.) By manipulating the loop enumerator, you can skip forward in 
the loop. Here’s an example:
PS (1) > foreach ($i in 1..10) 
>> { [void] $foreach.MoveNext(); $i + $foreach.current } 
>> 
11 
15 
19 
PS (2) >
In this example, the 
foreach
loop iterates over the collection of numbers from 1 to
10. In the body of the loop, the enumerator is used to advance the loop to the next 
element. It does this by calling the 
$foreach.MoveNext()
method and then retriev-
ing the next value using 
$foreach.current
. This lets you sum up each pair of num-
bers—(1,2), (3,4), and so on as the loop iterates.
NOTE
The 
foreach
statement can be used to iterate over anything 
PowerShell  considers  enumerable.  This  typically  includes  anything 
that  implements  the  .
NET
IEnumerable
interface, but PowerShell 
adapts that slightly. In particular, there are some classes that imple-
ment 
IEnumerable
that PowerShell doesn’t consider enumerable. 
This includes strings and dictionaries or hashtables. Because Power-
Shell unravels collections freely, you don’t want a string to suddenly be 
turned into a stream of characters or a hashtable to be shredded into a 
sequence of  key-value pairs. Hashtables  in particular  are commonly 
used as lightweight (that is, typeless) objects in the PowerShell environ-
ment, so you need to preserve their scalar nature.
The value stored in 
$foreach
is an instance of an object that implements the 
[Sys-
tem.Collections.IEnumerator]
interface. Here’s a quick example that shows you 
how to look at the members that are available on this object:
PS (1) > [System.Collections.IEnumerator].Getmembers()|foreach{"$_"} 
Boolean MoveNext()
System.Object get_Current()
Void Reset()
System.Object Current 
PS (2) >
The output of this statement shows the 
Current
and 
MoveNext()
members you’ve 
used. There’s also a 
Reset()
member that will reset the enumerator back to the start 
of the collection.
One final thing you need to know about the 
foreach
statement is how it treats 
scalar objects. Because of the way pipelines work, you don’t know ahead of time if the 
pipeline will return a collection or a single scalar object. In particular, if the pipeline
How to move pages around 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 page order in pdf reader; how to move pages around in a pdf document
How to move pages around 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
move pdf pages; rearrange pages in pdf file
L
OOPING
STATEMENTS
211
returns a single object, you can’t tell if it’s returning a scalar or a collection consisting 
of one object. You can use the 
@(
...
)
construction described in chapter 5 to force 
an array interpretation, but this ambiguity is common enough  that the 
foreach 
statement takes care of this by itself. A scalar object in the 
foreach
statement is auto-
matically treated as a one-element collection:
PS (2) > foreach ($i in "hi") {$i } 
hi
In this example, the value to iterate over is the scalar string “hi”. The loop executes 
exactly once, printing 
hi
. This works great most of the time, but there’s one “corner 
case” that can cause some problems, as you’ll see in the next section.
The foreach loop and $null
Now here’s something that really surprises (and sometimes irritates) people. What 
happens if the value to iterate over is 
$null
? Let’s find out:
PS (3) > foreach ($i in $null) { "executing" } 
Executing
So the loop executes. This illustrates that PowerShell treats 
$null
as a scalar value. 
Now compare this with the empty array:
PS (4) > foreach ($i in @()) { "executing" } 
PS (5) >
This time it doesn’t execute. The empty array is unambiguously a collection with no 
elements, which is quite different from a collection having one member whose value 
is 
$null
. In other words, 
@()
and 
@($null)
aren’t the same thing. For programmers 
who are used to 
$null
being nothing, this is a jarring notion. So why does Power-
Shell work this way? Let’s look at some more examples. First we’ll consider an exam-
ple where you pass in an array of three nulls:
PS {6) > foreach ($i in $null, $null, $null) {"hi"} 
hi 
hi 
hi
The statement prints 
hi
three times because there were three elements in the array. 
Now use an array of two elements
PS {7) > foreach ($i in $null, $null) {"hi"} 
hi 
hi
and it prints 
hi
twice. Logically, if there’s only one 
$null
, it should loop exactly once
PS {8) > foreach ($i in $null) {"hi"} 
hi
which is exactly what it does. PowerShell is deeply consistent, even in this case. This is 
not, though, the expected or even desired behavior in a 
foreach
loop in many cases,
C# WPF PDF Viewer SDK to view PDF document in C#.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Extract, Copy PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET Pan around the PDF document
reorder pages in a pdf; rearrange pdf pages in preview
VB.NET PDF - View PDF with WPF PDF Viewer for VB.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Copy, Paste PDF pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET Pan around the PDF document.
how to change page order in pdf acrobat; move pages in a pdf
212
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
so here’s how to work around it. You can use the 
Write-Output
cmdlet (aliased to 
write
) to preprocess the collection you want to iterate  over. If the argument  to 
Write-Output
is 
$null
, it doesn’t write anything to the output pipe:
PS {9) > foreach ($i in write $null) {"hi"}
PS {10) > 
And you see that the loop didn’t execute. So let’s run through the previous example 
with the arrays of nulls. First, with three nulls
PS {10) > foreach ($i in write $null,$null,$null) {"hi"} 
hi 
hi 
hi
and you get three iterations. Now with two
PS {11) > foreach ($i in write $null,$null) {"hi"} 
hi 
hi
and you get two iterations. Finally, with one 
$null
PS {12) > foreach ($i in write $null) {"hi"} 
PS {13) >
and  this  time  the  loop doesn’t execute.  Although this is inconsistent behavior, it 
matches user expectations and is a good trick to have in your toolkit.
NOTE
In the first edition of this book, I called this a corner case and 
suggested that most readers didn’t need to know about  this. I  was 
wrong. It comes up on a surprisingly regular basis. In fact, the work-
around  using 
Write-Output
was suggested by a user, not by the 
PowerShell team. Let’s hear it for the community!
On that note, let’s move on to a slightly different topic and talk about 
break
con-
tinue
, and using labeled loops to exit out of nested loop statements.
6.3
L
ABELS
BREAK
AND
CONTINUE
In this section, we’ll discuss how to do nonstructured exits from the various looping 
statements using the 
break
and 
continue
statements shown in figure 6.9. We’ll also 
cover labeled loops and how they work with 
break
and 
continue
. But first, some 
history.
In the dawn of computer languages, there was only one flow-control statement: 
goto
 Although  it  was  simple,  it  also  resulted  in  programs  that  were  hard  to
break                  break <label>
continue               continue <label>
The break and continue statements
Figure 6.9 The PowerShell 
break
and 
continue
statements, which 
may optionally take a label indicat-
ing which loop statement to break to
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Page: Replace PDF Pages. Page: Move Page Position. Page: Extract, Copy and Users can view PDF document in single page or continue pages. Pan around the document.
reorder pages in pdf document; how to reorder pages in pdf reader
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Page: Replace PDF Pages. Page: Move Page Position. Page: Copy, Paste PDF Users can view PDF document in single page or continue pages. Pan around the document.
rearrange pages in pdf; move pages in pdf
L
ABELS
BREAK
AND
CONTINUE
213
understand  and maintain.  Then along came  structured  programming. Structured 
programming introduced the idea of loops with single entry and exit points. This 
made programs much easier to understand and therefore maintain. Constructs such as 
while
loops and 
if/then/else
statements made it simpler to write programs that 
are easy to follow. 
NOTE
For the academically inclined reader, Wikipedia.org has a nice 
discussion on the topic of structured programming. 
So structured programming is great—that is, until you have to exit from a set of deeply 
nested 
while
loops. That’s when pure structured programming leads to pathologically 
convoluted logic because you have to litter your program with Boolean variables and 
conditionals trying to achieve the flow of control you need. This is when being a little 
“impure” and allowing the use of unstructured flow-control elements (including the 
infamous 
goto
statement) is useful. Now, PowerShell doesn’t actually have a 
goto 
statement. Instead, it has 
break
and 
continue
statements and labeled loops. Let’s look 
at some simple examples. Here’s a 
while
loop that stops counting at 5:
PS (1) > $i=0; while ($true) { if ($i++ -ge 5) { break } $i } 
PS (2) >
Notice in this example that the 
while
loop condition is simply 
$true
. Obviously, 
this loop would run forever were it not for the 
break
statement. As soon as 
$i
hits 5, 
the 
break
statement is executed and the loop terminates. Now let’s look at the 
con-
tinue
statement. In this example, you have a 
foreach
loop that loops over the num-
bers from 1 to 10:
PS (1) > foreach ($i in 1..10) 
>> { 
>>     if ($i % 2) 
>>     { 
>>         continue 
>>     } 
>>     $i 
>> } 
>> 
10 
PS (2) >
If the number isn’t evenly divisible by 2, then the 
continue
statement is executed. 
Where the 
break
statement immediately terminates the loop, the 
continue
state-
ment causes the flow of execution to jump back to the beginning of the loop and
214
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
move on to the next iteration. The end result is that only even numbers are emitted. 
The 
continue
statement skips the line that would have printed the odd numbers.
So the basic 
break
and 
continue
statements can handle flow control in a single 
loop. But what about nested loops, which was the real problem you wanted to address? 
This is where labels come in. Before the initial keyword on any of PowerShell’s loop 
statements, you can add a label naming that statement. Then you can use the 
break 
and 
continue
keywords to jump to that statement. Here’s a simple example:
:outer while (1) 
{
while(1)
{
break outer;
}
In this example, without the 
break
statement, the loop would repeat forever. Instead, 
the 
break
will take you out of both the inner and outer loops.
NOTE
In PowerShell, labeled 
break
and 
continue
statements have 
one rather strange but occasionally useful characteristic: they’ll con-
tinue to search up the calling stack until a matching label is found. This 
search will even cross script and function call boundaries. This means 
that a break inside a function inside a script can transfer control to an 
enclosing loop in the calling script. This allows for wide-ranging trans-
fer of control. This will make more sense when you get to chapter 7, 
where functions are introduced.
One last thing to know about the 
break
and 
continue
statements—the name of the 
label to jump to is actually an expression, not a constant value. You could, for exam-
ple, use a variable to name the target of the statement. Let’s try this out. First set up a 
variable to hold the target name:
PS (1) > $target = "foo"
Now use it in a loop. In this loop, if the least significant bit in the value stored in 
$i 
is 1 (yet another way to test for odd numbers), you skip to the next iteration of the 
loop named by 
$target
PS (2) > :foo foreach ($i in 1..10) { 
>> if ($i -band 1) { continue $target } $i 
>> } 
>> 
10 
PS (3) >
which produces a list of the even numbers in the range 1..10.
T
HE
SWITCH
STATEMENT
215
At this point, we’ve covered all of the basic PowerShell flow-control statements, as 
well as using labels and 
break
/
continue
to do nonlocal flow-control transfers. Now 
let’s move on to the 
switch
statement, which in PowerShell combines both looping 
and branching capabilities. 
6.4
T
HE
SWITCH
STATEMENT
The 
switch
statement, shown in figure 6.10, is the most powerful statement in the 
PowerShell language. This statement  combines  pattern  matching, branching, and 
iteration all into a single control structure. This is why it gets its own section instead 
of being covered under either loops or conditionals. 
At the most basic level, the 
switch
statement in PowerShell is similar to the 
switch
statement in many other languages—it’s a way of selecting an action based 
on a particular value. But the PowerShell 
switch
statement has a number of addi-
tional capabilities. It can be used as a looping construct where it processes a collection 
of objects instead of just a single object. It supports the advanced pattern matching 
features that you’ve seen with the 
-match
and 
-like
operators. (How the pattern is 
matched depends on the flags specified to the 
switch
statement.) Finally, it can be 
used to efficiently process an entire file in a single statement. 
6.4.1
Basic use of the switch statement 
Let’s begin by exploring the basic functions of the 
switch
statement. See figure 6.11 
for a look at its syntax in detail.
Figure 6.11 The PowerShell 
switch
statement syntax. The switch options control 
how matching is done. These options are 
-regex
-wildcard
-match
, and 
-case
The pipeline produces values to switch on; alternatively, you can specify the sequence 
-file <expr>
instead of 
( <pipeline> )
. All matching pattern/action clauses 
are executed; the default clause is executed only if there are no other matches.
switch ( <expr> ) { <pattern1> { <statements> } <pattern2> { <statements> } }
switch ( <expr> ) { <pattern1> { <statements> } default { <statements> } }
The switch statement
Figure 6.10 The PowerShell 
switch
statement syntax
switch -options  ( <pipeline> )
<pattern>  {  <statementList>  }
<pattern>  { <statementList>  }
default
{ <statementList>  }
}
switch keyword
Switch options
Default keyword
Pipeline producing values
to switch on
Pattern/action clauses
216
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
This is a pretty complex construct, so let’s start by looking at the simplest form of the 
statement. Here’s the basic example:
PS (1) > switch (1) { 1 { "One" } 2 { "two" } }
One
The value to switch on is in the parentheses after the 
switch
keyword. In this exam-
ple, it’s the number 1. That value is matched against the pattern in each clause and all 
matching actions are taken. You’ll see how to change this in a second. 
In this example, the switch value matches 1 so that clause emits the string “one”. 
Of course, if you change the switch value to 2, you get
PS (2) > switch (2) { 1 { "One" } 2 { "two" } } 
two
Now try a somewhat different example. In this case, you have two clauses that match 
the switch value:
PS (4) > switch (2) { 1 { "One" } 2 { "two" } 2 {"another 2"} } 
two 
another 2
You can see that both of these actions are executed. As we stated earlier, the 
switch 
statement executes all clauses that match the switch value. If you want to stop at the 
first match, you use the 
break
statement:
PS (5) > switch (2) {1 {"One"} 2 {"two"; break} 2 {"another 2"}} 
two
This causes the matching process to stop after the first matching statement was exe-
cuted. But what happens if no statements match? Well, the statement quietly returns 
nothing:
PS (6) > switch (3) { 1 { "One" } 2 { "two"; break } 2 {"another 2"} } 
PS (7) >
To specify a default action, you can use the 
default
clause:
PS (7) > switch (3) { 1 { "One" } 2 { "two" } default {"default"} } 
default 
PS (8) > switch (2) { 1 { "One" } 2 { "two" } default {"default"} } 
Two
In this example, when the switch value is 3, no clause matches and the default clause 
is run. But when there’s a match, the default isn’t run, as it’s not considered a match. 
This covers the basic mode of operation. Now let’s move on to more advanced features.
6.4.2
Using wildcard patterns with the switch statement 
By default, the matching clauses make an equivalence comparison against the object 
in the clause. If the matching object is a string, the check is done in a case-insensitive 
way, as you see in the next example:
T
HE
SWITCH
STATEMENT
217
PS (1) > switch ('abc') {'abc' {"one"} 'ABC' {"two"}} 
one 
two
The switch value “abc” in this example was matched by both “abc” and “ABC”. You 
can change this behavior by specifying the 
-casesensitive
option:
PS (2) > switch -case ('abc') {'abc' {"one"} 'ABC' {"two"}} 
one
Now the match occurs only when the case of the elements match. 
NOTE
In this example, we only used the prefix 
-case
instead of the 
full option string. In fact, only the first letter of the option is checked.
Next, let’s discuss the next 
switch
option, the 
-wildcard
option. When 
-wildcard 
is specified, the switch value is converted into a string and the tests are conducted 
using the wildcard pattern. (Wildcard patterns were discussed in chapter 4 with the 
-like
operator.) This is shown in the next example:
PS (4) > switch -wildcard ('abc') {a* {"astar"} *c {"starc"}} 
astar 
starc
In this example, the pattern 
a*
matches anything that begins with the letter “a” and 
the pattern 
*c
matches anything that ends with the letter “c.” Again, all matching 
clauses are executed.
There’s one more element to mention at this point. When a clause is matched, the 
element that matched is assigned to the variable 
$_
before running the clause. This is 
always done, even in the simple examples we discussed earlier, but it wasn’t interest-
ing because you were doing exact comparisons so you already knew what matched. 
Once you introduce patterns, it’s much more useful to be able to get at the object 
that matched. For example, if you’re matching against filename extensions, you’d 
want to be able to get at the full filename to do any processing on that file. We’ll look 
at some more practical uses for this feature in later sections. For now, here’s a basic 
example that shows how this match works:
PS (5) > switch -wildcard ('abc') {a* {"a*: $_"} *c {"*c: $_"}} 
a*: abc
*c: abc
In the result strings, you can see that 
$_
was replaced by the full string of the actual 
switch value.
6.4.3
Using regular expressions with the switch statement 
As we discussed in chapter 4, the wildcard patterns, while useful, have limited capa-
bilities.  For  more  sophisticated  pattern  matching,  you  used  regular  expressions.
218
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
Regular expressions are available in the 
switch
statement through the 
-regex
flag. 
Let’s rewrite the previous example using regular expressions instead of wildcards:
PS (6) > switch -regex ('abc') {^a {"a*: $_"} 'c$' {"*c: $_"}} 
a*: abc
*c: abc
As you see, 
$_
is still bound to the entire matching key. But one of the most powerful 
features of regular expressions is submatches. A submatch, or capture, is a portion of 
the regular expression that’s enclosed in parentheses, as discussed in chapter 4 with 
the 
-match
operator. With the 
-match
operator, the submatches are made available 
through the 
$matches
variable. This same variable is also used in the 
switch
state-
ment. The next example shows how this works:
PS (8) > switch -regex ('abc') {'(^a)(.*$)' {$matches}}
Key                            Value 
---                            -----
                             bc 
                             a 
                             abc
In the result shown here, 
$matches[0]
is the overall key; 
$matches[1]
is the first 
submatch, in this case the leading “a”; and 
$matches[2]
is the remainder of the 
string. As always, matching is case insensitive by default, but you can specify the 
-case
option to make it case sensitive, as shown here:
PS (9) > switch -regex ('abc') {'(^A)(.*$)' {$matches}}
Key                            Value 
---                            -----
                             bc 
                             a 
                             abc
PS (10) > switch -regex -case  ('abc') {'(^A)(.*$)' {$matches}}
In the first command, you changed the match pattern from 
a
to 
A
and the match still 
succeeded because case was ignored. In the second command, you added the 
-case 
flag and this time the match didn’t succeed.
So far we’ve discussed three ways to control how matching against the switch 
value works—in other words, three matching modes (actually six, because the 
-case 
flag can be used with any of the previous three). But what if you need something a bit 
more sophisticated than a simple pattern match? The 
switch
statement lets you han-
dle this by specifying an expression in braces instead of a pattern. In the next exam-
ple, you specify two expressions that check against the switch value. Again the switch 
value is made available through the variable 
$_:
PS (11) > switch (5) { 
>> {$_ -gt 3} {"greater than three"} 
>> {$_ -gt 7} {"greater than 7"}}
T
HE
SWITCH
STATEMENT
219
>> 
greater than three 
PS (12) > switch (8) { 
>> {$_ -gt 3} {"greater than three"} 
>> {$_ -gt 7} {"greater than 7"}} 
>> 
greater than three 
greater than 7 
PS (13) >
In the first statement, only the first clause was triggered because 5 is greater than 3 
but less than 7. In the second statement, both clauses fired.
You can use these matching clauses with any of the other three matching modes:
PS (13) > switch (8) { 
>> {$_ -gt 3} {"greater than three"} 
>> 8 {"Was $_"}} 
>> 
greater than three 
Was 8
The first expression, 
{$_  -gt  3}
, evaluated to true so “greater than three” was 
printed, and the switch value matched 8 so “Was 8” also printed (where 
$_
was 
replaced by the matching value).
Now you  have  exact  matches,  pattern  matches,  conditional  matches,  and  the 
default clause. But what about the switch value itself? So far, all the examples have 
been simple scalar values. What happens if you specify a collection of values? This is 
where the 
switch
statement acts like a form of loop.
NOTE
switch
works like the other looping statements in that the 
expression in the parentheses is fully evaluated before it starts iterating 
over the individual values.
Let’s look at another example where you specify an array of values:
PS (2) > switch(1,2,3,4,5,6) { 
>> {$_ % 2} {"Odd $_"; continue} 
>> 4 {"FOUR"} 
>> default {"Even $_"} 
>> } 
>>
Odd 1 
Even 2 
Odd 3 
FOUR 
Odd 5 
Even 6
In this example, the switch value is 
1,2,3,4,5,6
. The 
switch
statement loops over 
the collection, testing each element against all the clauses. The first clause returns 
“Odd 
$_
” if the current switch element isn’t evenly divisible by 2. The next clause 
prints out 
“FOUR”
if the value is 4. The default clause prints out “Even $_” if the
Documents you may be interested
Documents you may be interested