c# pdf viewer free : How to rearrange pdf pages reader Library SDK class asp.net wpf azure ajax Windows%20Powershell%20in%20Action%202nd%20Edition25-part1478

220
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
number is even. Note the use of 
continue
in the first clause. This tells the 
switch 
statement to stop matching any further clauses and move on to the next element in 
the collection. In this instance, the 
switch
statement is working in the same way that 
the 
continue
statement works in the other loops. It skips the remainder of the body 
of the loop and continues on with the next loop iteration. What happens if you used 
break
instead of 
continue
?
PS (3) > switch(1,2,3,4,5,6) { 
>> {$_ % 2} {"Odd $_"; break} 
>> 4 {"FOUR"} 
>> default {"Even $_"} 
>> } 
>>
Odd 1
As with the other loops, 
break
doesn’t just skip the remainder of the current itera-
tion; it terminates the overall loop processing. (If you want to continue iterating, use 
continue
instead. More on that later.)
Of course, iterating over a fixed collection isn’t very interesting. In fact, you can 
use a pipeline in the switch value, as the next example shows. In this example, you 
want to count the number of 
DLL
s, text files, and log files in the directory c:\win-
dows. First you initialize the counter variables:
PS (1) > $dll=$txt=$log=0
Now you run the actual 
switch
statement. This 
switch
statement uses wildcard pat-
terns to match the extensions on the filenames. The associated actions increment a 
variable for each extension type:
PS (2) > switch -wildcard (dir c:\windows) 
>> {*.dll {$dll++} *.txt {$txt++} *.log {$log++}}
Once you have the totals, display them:
PS (3) > "dlls: $dll text files: $txt log files: $log" 
dlls: 6 text files: 9 log files: 120
Note that in this example the pipeline element is being matched against every clause. 
Because a file can’t have more than one extension, this doesn’t affect the output, but it 
does affect performance somewhat. It’s faster to include a 
continue
statement after 
each clause so the matching process stops as soon as the first match succeeds.
Here’s something else we glossed over earlier in our discussion of 
$_
—it always 
contains the object that was matched against. This is important to understand when 
you’re using  the pattern matching modes of  the 
switch
statement. The pattern 
matches create a string representation of the object to match against, but 
$_
is still 
bound to the original object. Here’s an example that illustrates this point. This is 
basically the same as the previous example, but this time, instead of counting the 
number of files, you want to calculate the total size of all the files having a particular 
extension. Here are the revised commands:
How to rearrange pdf pages reader - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
reorder pages of pdf; how to move pages within a pdf
How to rearrange pdf pages reader - 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 pages pdf file; pdf reverse page order preview
T
HE
SWITCH
STATEMENT
221
PS (1) > $dll=$txt=$log=0 
PS (2) > switch -wildcard (dir) { 
>> *.dll {$dll+= $_.length; continue} 
>> *.txt {$txt+=$_.length; continue} 
>> *.log {$log+=$_.length; continue} 
>> } 
>>
PS (3) > "dlls: $dll text files: $txt log files: $log" 
dlls: 166913 text files: 1866711 log files: 6669437 
PS (4) >
Notice how you’re using 
$_.length 
to get the length of the matching file object. If 
$_
were bound to the matching string, you’d be counting the lengths of the filenames 
instead of the lengths of the actual files.
6.4.4
Processing files with the switch statement 
There’s one last mode of operation for the 
switch
statement to discuss: the 
-file 
option. Instead of specifying an expression to iterate over as the switch value, the 
-file 
option allows you to name a file to process. Here’s an example that processes the Win-
dows update log file. Again start by initializing the counter variables:
PS (1) > $au=$du=$su=0
Next  use  the 
-regex
and 
-file
options to access and scan the file Windows-
Update.log,  and  check  for  update  requests  from  Windows  Update,  Windows 
Defender, and 
SMS
:
PS (2) > switch -regex -file c:\windows\windowsupdate.log { 
>> 'START.*Finding updates.*AutomaticUpdates' {$au++} 
>> 'START.*Finding updates.*Defender' {$du++} 
>> 'START.*Finding updates.*SMS' {$su++} 
>> } 
>>
Print the results:
PS (3) > "Automatic:$au Defender:$du SMS:$su" 
Automatic:195 Defender:10 SMS:34
Now it’s possible to do basically the same thing by using 
Get-Content
or even the 
file system name trick you learned in chapter 4:
PS (4) > $au=$du=$su=0
PS (5) > switch -regex (${c:windowsupdate.log}) { 
>> 'START.*Finding updates.*AutomaticUpdates' {$au++} 
>> 'START.*Finding updates.*Defender' {$du++} 
>> 'START.*Finding updates.*SMS' {$su++} 
>> } 
>>
PS (6) > "Automatic:$au Defender:$du SMS:$su" 
Automatic:195 Defender:10 SMS:34
This code uses 
${c:windowsupdate.log}
to access the file content instead of 
-file
So why have the 
-file
option? There are two reasons.
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
C# TIFF - Sort TIFF File Pages Order in C#.NET. Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview.
rearrange pdf pages; change page order in pdf file
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
you want to change or rearrange current TIFF &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
pdf change page order acrobat; reordering pdf pages
222
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
The 
-file
operation reads one line at a time, so it uses less memory than the 
Get-Content
cmdlet, which has to read the entire file into memory before process-
ing. Also, because 
-file
is part of the PowerShell language, the interpreter can do 
some optimizations, which gives 
-file
performance advantages. 
So,  overall, the 
-file
option can potentially give you both speed and space 
advantages in some cases (the space advantage typically being the more significant, 
and therefore the more important of the two). When your task involves processing a 
lot of text files, the 
-file
switch can be a useful tool.
6.4.5
Using the $switch loop enumerator in the switch statement 
One more point: just as the 
foreach
loop used 
$foreach
to hold the loop enumera-
tor, the 
switch
statement uses 
$switch
to hold the switch loop enumerator. This is 
useful in a common pattern—processing a list of options. Say you have a list of 
options where the option 
-b
takes an argument and 
-a
-c
, and 
-d
don’t. You’ll write 
switch
statement to process a list of these arguments. First set up a list of test 
options. For convenience, start with a string and then use the 
-split
operator to 
break it into an array of elements:
PS (1) > $options= -split "-a -b Hello -c"
Next initialize the set of variables that will correspond to the flags:
PS (2) > $a=$c=$d=$false 
PS (3) > $b=$null
Now you can write your 
switch
statement. The interesting clause is the one that 
handles 
-b
. This clause uses the enumerator stored in 
$switch
to advance the item 
being processed to the next element in the list. Use a cast to 
[void]
to discard the 
return value from the call to 
$switch.movenext()
(more on that later). Then use 
$switch.current
to retrieve the next value and store it in 
$b
. The loop continues 
processing the remaining arguments in the list.
PS (4) > switch ($options) 
>> { 
>> '-a' { $a=$true } 
>> '-b' { [void] $switch.movenext(); $b= $switch.current } 
>> '-c' { $c=$true } 
>> '-d' { $d=$true } 
>> } 
>>
The last step in this example is to print the arguments in the list to make sure they 
were all set properly:
PS (5) > "a=$a b=$b c=$c d=$d" 
a=True b=Hello c=True d=False 
PS (6) >
You see that 
$a
and 
$c
are true, 
$b
contains the argument “Hello”, and 
$d
is still false 
because it wasn’t in your list of test options. The option list has been processed correctly.
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
page directly. Moreover, when you get a PDF document which is out of order, you need to rearrange the PDF document pages. In these
how to move pages in a pdf file; how to move pages in pdf files
C# PowerPoint - How to Process PowerPoint
pages simply with a few lines of C# code. C# Codes to Sort Slides Order. If you want to use a very easy PPT slide dealing solution to sort and rearrange
how to move pages in a pdf document; rearrange pdf pages online
F
LOW
CONTROL
USING
CMDLETS
223
NOTE
This isn’t a robust example because it’s missing all error hand-
ing. In a complete example, you’d have a default clause that generated 
errors for unexpected options. Also, in the clause that processes the 
argument for 
-b
, rather than discarding the result of 
MoveNext()
it 
should check the result and generate an error if it returns false. This 
would indicate that there are no more elements in the collection, so 
-b 
would be missing its mandatory argument.
This finishes the last of the flow-control statements in the PowerShell language, but as 
you saw at the beginning of this chapter, there’s another way to do selection and iter-
ation in PowerShell by using cmdlets. In the next section, we’ll go over a couple of the 
cmdlets that are a standard part of the PowerShell distribution. These cmdlets let you 
control the flow of your script in a manner similar to the flow-control statements. (In 
later sections, we’ll look at how you can create your own specialized flow-control ele-
ments in PowerShell.)
6.5
F
LOW
CONTROL
USING
CMDLETS
PowerShell’s control statements are part of the language proper, but there are also 
some cmdlets, shown in figure 6.12, that can be used to accomplish similar kinds of 
things. 
Figure 6.12 Flow-control cmdlets
These  cmdlets  use blocks  of PowerShell script  enclosed in braces to  provide  the 
“body” of the control statement. These pieces of script are called scriptblocks and are 
described in detail in chapter 8. The two most frequent flow-control cmdlets that 
you’ll encounter are 
ForEach-Object 
and
Where-Object.
6.5.1
The ForEach-Object cmdlet
The 
ForEach-Object
cmdlet operates on each object in a pipeline in much the same 
way that the 
foreach
statement operates on the set of values that are provided to it. 
For example, here’s a 
foreach
statement that prints the size of each text file in the 
current directory:
PS (1) > foreach ($f in dir *.txt) { $f.length } 
48 
889 
23723 
328 
279164
Flow-control cmdlets
… | ForEach-Object <scriptBlock> 
… | ForEach-Object -Begin <scriptBlock> -Process <scriptBlock> -End <scriptBlock>
… | Where-Object <scriptBlock>
VB.NET Word: How to Process MS Word in VB.NET Library in .NET
well programmed Word pages sorter to rearrange Word pages in extracting single or multiple Word pages at one & profession imaging controls, PDF document, image
reorder pages in pdf file; pdf rearrange pages
Process Images in Web Image Viewer | Online Tutorials
used document types are supported, including PDF, multi-page easy to process image and file pages with the deleting a thumbnail, and you can rearrange the file
rearrange pages in pdf online; how to reorder pdf pages
224
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
Using the 
ForEach-Object
cmdlet, the same task can be accomplished this way:
PS (2) > dir *.txt | foreach-object {$_.length} 
48 
889 
23723 
328 
279164
The results are the same, so what’s the difference? One obvious difference is that you 
don't have to create a new variable name to hold the loop value. The automatic vari-
able 
$_
is used as the loop variable.
NOTE
Automatic variables are common in scripting languages. These 
variables aren’t directly assigned to in scripts. Instead, they are set as 
the side effect of an operation. One of the earlier examples of this is in 
AWK
. When a line is read in 
AWK
, the text of the line is automatically 
assigned to 
$0
. The line is also split into fields. The first field is placed 
in 
$1
, the second is in 
$2
, and so on. The Perl language is probably the 
most significant user of automatic variables. In fact, as mentioned pre-
viously, Perl inspired the use of 
$_
in PowerShell. Automatic variables 
can help reduce the size of a script, but they can also make a script hard 
to read and difficult to reuse because your use of automatics may collide 
with mine. From a design perspective, our approach with automatic 
variables follows the salt curve. A little salt makes everything taste bet-
ter. Too much salt makes food inedible. The language design team 
tried to keep the use of automatics in PowerShell at the “just right” 
level. Of course, this is  always a subjective  judgment. Some people 
really like salt.
A more subtle difference, as discussed previously, is that the loop is processed one 
object at a time. In a normal 
foreach
loop, the entire list of values is generated 
before a single value is processed. In the 
ForEach-Object
pipeline, each object is 
generated and then passed to the cmdlet for processing. 
The 
ForEach-Object
cmdlet has an advantage over the 
foreach
loop in the 
amount of space being used at a particular time. For example, if you’re processing a 
large file, the 
foreach
loop would have to load the entire file into memory before 
processing. When you use the 
ForEach-Object
cmdlet, the file will be processed 
one line  at  a time.  This significantly  reduces the  amount of memory  needed to 
accomplish a task.
You’ll end up using the 
ForEach-Object
cmdlet a lot in command lines to per-
form simple transformations on objects (you’ve already used it in many examples so 
far). Given the frequency of use, there are two standard aliases for this cmdlet. The 
first one is (obviously) 
foreach
. But wait a second—didn’t we say earlier in this 
chapter that 
foreach
is a keyword and keywords can’t be aliased? This is true, but
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
page will teach you to rearrange and readjust amount of robust PPT slides/pages editing methods and powerful & profession imaging controls, PDF document, image
how to rearrange pages in pdf document; reverse page order pdf online
F
LOW
CONTROL
USING
CMDLETS
225
remember, keywords are only special when they’re the first unquoted word in a state-
ment (in other words, not a string). If they appear anywhere else (for example, as an 
argument or in the middle of a pipeline), they’re just another command with no spe-
cial meaning to the language. Here’s another way to think about it: the first word in a 
statement is the key that the PowerShell interpreter uses to decide what kind of state-
ment it’s processing, hence the term “keyword.”
This positional constraint is how the interpreter can distinguish between the key-
word 
foreach
foreach ($i in 1..10) { $i }
and the aliased cmdlet 
foreach
:
1..10 | foreach {$_}
When 
foreach
is the first word in a statement, it’s a keyword; otherwise it’s the name 
of a command. 
Now let’s look at the second alias. Even though 
foreach
is significantly shorter 
than 
ForEach-Object
, there have still been times when users wanted it to be even 
shorter.
NOTE
Users  wanted to  get rid  of this  notation  entirely  and  have 
foreach
be implied by an open brace following the pipe symbol. This 
would have made about half of PowerShell users very happy. Unfortu-
nately,  the other  half  were  adamant  that  the implied operation be 
Where-Object
instead of 
ForEach-Object
.
Where extreme brevity is required, there’s a second built-in alias that’s simply the per-
cent sign (
%
). Now readers are saying, “You told us the percent sign is an operator!” 
Well, that’s true, but only when it’s used as a binary operator. If it appears as the first 
symbol in a statement, it has no special meaning, so you can use it as an alias for 
ForEach-Object
. As with keywords, operators are also context sensitive. 
The 
%
alias you write results in very concise (but occasionally hard-to-read) state-
ments such as the following, which prints the numbers from 1 to 5, times 2:
PS (1) > 1..5|%{$_*2} 
10 
PS (2) >
Clearly this construction is great for interactive use where brevity is important, but it 
probably shouldn’t be used when writing scripts. The issue is that 
ForEach-Object 
is so useful that a single-character symbol for it, one that is easy to distinguish, is 
invaluable for experienced PowerShell users. But unlike the word 
foreach
%
isn’t 
immediately meaningful to new users. So this notation is great for “conversational”
226
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
PowerShell, but generally terrible for scripts that you want other people to be able to 
read and maintain.
The last thing to know about the 
ForEach-Object
cmdlet is that it can take mul-
tiple scriptblocks. If three scriptblocks are specified, the first one is run before any 
objects are processed, the second is run once for each object, and the last is run after 
all objects have been processed. This is good for conducting accumulation-type oper-
ations. Here’s another variation that sums the number of handles used by the service 
host 
svchost
processes:
PS (3) > gps svchost |%{$t=0}{$t+=$_.handles}{$t} 
3238
The standard alias for 
Get-Process
is 
gps
. This is used to get a list of processes 
where the process name matches 
svchost
. These process objects are then piped into 
ForEach-Object
, where the handle counts are summed up in 
$t
and then emitted 
in the last scriptblock. This example uses the 
%
alias to show how concise these 
expressions can be. In an interactive environment, brevity is important.
And  here’s  something  to  keep  in  mind  when  using 
ForEach-Object
 The 
ForEach-Object
cmdlet works like all cmdlets: if the output object is a collection, it 
gets unraveled. One way to suppress this behavior is to use the unary comma opera-
tor. For example, in the following, you assign 
$a
an array of two elements, the second 
of which is a nested array:
PS (1) > $a =  1,(2,3)
When you check the length, you see that it is 2 as expected
PS (2) > $a.length 
2
and the second element is still an array:
PS (3) > $a[1] 
3
But if you run it through 
ForEach-Object
, you’ll find that the length of the result is 
now 3, and the second element in the result is the number 2:
PS (4) > $b = $a | foreach { $_ } 
PS (5) > $b.length 
PS (6) > $b[2] 
2
In effect, the result has been “flattened.” But if you use the unary comma operator 
before the 
$_
variable, the result has the same structure as the original array:
PS (7) > $b = $a | foreach {
, $_ } 
PS (8) > $b.length 
PS (9) > $b[1]
F
LOW
CONTROL
USING
CMDLETS
227
2
3
When chaining 
foreach
cmdlets, you need to repeat the pattern at each stage:
PS (7) > $b = $a | foreach {
, $_ } | foreach {
,
$_
PS (8) > $b.length 
PS (9) > $b[1] 
3
Why don't you just preserve the structure as you pass the elements through instead of 
unraveling by default? Well, both behaviors are, in fact, useful. Consider the follow-
ing example, which returns a list of loaded module names:
Get-Process | %{$_.modules} | sort -u modulename
Here the unraveling is exactly what you want. When we were designing PowerShell, 
we considered both cases; and in applications, on average, unraveling by default was 
usually what we  needed.  Unfortunately,  it does  present  something of a cognitive 
bump that surprises users learning to use PowerShell.
Using the return statement with ForEach-Object
Here’s another tidbit of information about something that occasionally causes prob-
lems.  Although  the 
ForEach-Object
cmdlet looks like a PowerShell statement, 
remember that it is in fact a command and the body of code it executes is a script-
block, also known as an anonymous function. (By anonymous, we just mean that we 
haven’t given it a name. Again, we cover this in detail in chapter 11.) The important 
thing to know is that the 
return
statement (see chapter 7), when used in the script-
block argument to 
ForEach-Object
, only exits from the 
ForEach-Object
script-
block, not from the function or script that is calling 
ForEach-Object
. So, if you do 
want to return out of a function or script in a 
foreach
loop, either use the 
foreach 
statement where the 
return
will work as desired, or use the nonlocal labeled 
break 
statement discussed earlier in this chapter.
How ForEach-Object processes its arguments
Let’s talk for a moment about how the 
ForEach-Object
cmdlet processes its argu-
ment scriptblocks. A reader of the first edition of this book observed what he thought 
was an inconsistency between how the cmdlet is documented and how the following 
example behaves:
$words | ForEach-Object {$h=@{}} {$h[$_] += 1}
The help text for the cmdlet (use 
help ForEach-Object -Full
to see this text) says 
that the 
-Process
parameter is the only positional parameter and that it’s in position
1. Therefore, according to the help file, since the 
-Begin
parameter isn’t positional, 
the example shouldn’t work. This led the reader to assume that either there was an 
error in the help file, or that he misunderstood the idea of positional parameters.
228
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
In fact the help file is correct (because the cmdlet information is extracted from 
the code) but the way it works is tricky.
If you look at the signature of the 
-Process
parameter, you'll see that, yes, it is 
positional, but it also takes a collection of scriptblocks and receives all remaining 
unbound arguments. So, in the case of
dir | foreach {$sum=0} {$sum++} {$sum}
the 
-Process
parameter is getting an array of three scriptblocks, whereas 
-Begin
and 
-End
are empty. Now here’s the trick. If 
-Begin
is empty and 
-Process
has more 
than two scriptblocks in the collection, then the first one is treated as the 
-Begin 
scriptblock and the second one is treated as the -
Process
scriptblock. If -
Begin
is 
specified but -
End
is not and there are two scriptblocks, then the first one is treated as 
the 
Process
clause and the second one is the 
End
clause. Finally, if both 
-Begin
and 
-End
are specified, the remaining arguments will be treated as multiple 
Process 
clauses. This allows 
dir | foreach {$sum=0} {$sum++} {$sum} 
dir | foreach -begin {$sum=0} {$sum++} {$sum} 
dir | foreach {$sum=0} {$sum++} -end {$sum} 
dir | foreach -begin {$sum=0} {$sum++} -end {$sum}
and
dir | foreach -begin {$sum=0} -process {$sum++} -end {$sum}
to all work as expected.
On  that note,  we’re  finished  with  our discussion of 
ForEach-Object
 We’ll 
touch on it again in chapter 8 when we discuss scriptblocks, but for now, let’s move 
on to the other flow-control cmdlet commonly used in PowerShell (which, by the 
way, also uses scriptblocks—you may detect a theme here).
6.5.2
The Where-Object cmdlet
The other common flow-control cmdlet is the 
Where-Object cmdlet
. This cmdlet 
is used to select objects from a stream, kind of like a simple 
switch
cmdlet. It takes 
each pipeline element it receives as input, executes its scriptblock (see!) argument, 
passing in the current pipeline element as 
$_
, and then, if the scriptblock evaluates to 
true, the element is written to the pipeline. We’ll show this with yet another way to 
select even numbers from a sequence of integers:
PS (4) > 1..10 | where {-not ($_ -band 1)} 
10
The  scriptblock  enclosed  in the  braces receives  each  pipeline  element,  one  after 
another. If the least significant bit in the element is 1, then the scriptblock returns the
F
LOW
CONTROL
USING
CMDLETS
229
logical complement of that value (
$false
) and that element is discarded. If the least 
significant bit is 0, the logical complement of that is 
$true
and the element is written 
to the output pipeline. Notice that the common alias for 
Where-Object
is simply 
where
. And, as with 
ForEach-Object
, because this construction is so commonly 
used interactively, there’s an additional alias, which is simply the question mark (
?
). 
This allows the previous example to be written as
PS (5) > 1..10|?{!($_-band 1)} 
10
Again, this is brief, but it looks like the cat walked across the keyboard (trust me on 
this one). So, as before, although this is fine for interactive use, it isn’t recommended 
in scripts because it’s hard to understand and maintain. As another, more compelling 
example of “Software by Cats,” here’s a pathological example that combines elements 
from the last few chapters—type casts, operators, and the flow-control cmdlets—to 
generate a list of strings of even-numbered letters in the alphabet, where the length of 
the string matches the ordinal number in the alphabet (
“A”
is 1, 
“B”
is 2, and so on):
PS (1) > 1..26|?{!($_-band 1)}|%{[string][char]([int][char]'A'+$_-1)*$_} 
>>
BB 
DDDD 
FFFFFF 
HHHHHHHH 
JJJJJJJJJJ 
LLLLLLLLLLLL 
NNNNNNNNNNNNNN 
PPPPPPPPPPPPPPPP 
RRRRRRRRRRRRRRRRRR 
TTTTTTTTTTTTTTTTTTTT 
VVVVVVVVVVVVVVVVVVVVVV 
XXXXXXXXXXXXXXXXXXXXXXXX 
ZZZZZZZZZZZZZZZZZZZZZZZZZZ 
PS (2) >
The output is fairly self-explanatory, but the code isn’t. Figuring out how this works is 
left as an exercise to the reader and as a cautionary tale not to foist this sort of rubbish 
on unsuspecting coworkers. They know where you live.
Where-Object and Get-Content’s -ReadCount Parameter 
On occasion,  a question  comes  up  about  the 
Get-Content
cmdlet and how its 
-ReadCount 
parameter works. This can be an issue particularly when using this cmd-
let and parameter with 
Where-Object
to filter the output of 
Get-Content
. The issue 
comes up when the read count is greater than 1. This causes PowerShell to act as if 
some of the objects returned from 
Get-Content
are being skipped and affects both
Documents you may be interested
Documents you may be interested