c# pdf viewer free : Move pdf pages in preview software control dll windows web page html web forms Windows%20Powershell%20in%20Action%202nd%20Edition26-part1479

230
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
ForEach-Object
and 
Where-Object
. After all, these cmdlets are supposed to process 
or filter the input one object at a time and this isn’t what appears to be happening.
Here’s what’s going on. Unfortunately the 
-ReadCount
parameter has a confusing 
name. From the PowerShell user’s perspective, it has nothing to do with reading. 
What it does is control the number for records written to the next pipeline element, in 
this case 
Where-Object
or 
ForEach-Object.
The following examples illustrate how 
this works. In these examples, you’ll  use a simple text file named test.txt, which 
contains 10 lines of text and the 
ForEach-Object
cmdlet (through its alias 
%
) to 
count the length of each object being passed down the pipeline. You’ll use the 
@( … ) 
construct to guarantee that you’re always treating 
$_
as an array. Here are the exam-
ples with 
-readcount
varying from 1 to 4:
PS (119) > gc test.txt -ReadCount 1 | % { @($_).count } | select -fir 1 
PS (120) > gc test.txt -ReadCount 2 | % { @($_).count } | select -fir 1 
PS (121) > gc test.txt -ReadCount 3 | % { @($_).count } | select -fir 1 
PS (122) > gc test.txt -ReadCount 4 | % { @($_).count } | select -fir 1 
4
In each case where 
-ReadCount 
is greater than 1, the variable
$_
is set to a collection 
of objects where the object count of that collection is equivalent to the value specified 
by 
-ReadCount
. In another example, you’ll use 
ForEach-Object
to filter the pipeline:
PS (127) > gc test.txt -read 5 | ? {$_ -like '*'} | % { $_.count } 
5
You can see that the filter result contains two collections of 5 objects each written to 
the pipeline for a total of 10 objects. Now use 
ForEach-Object
and the 
if
state-
ment to filter the list:
PS (128) > (gc test.txt -read 10 | % {if ($_ -match '.') {$_}} | 
>>> Measure-Object).count 
>>> 
10
This time you see a count of 10 because the value of 
$_
in the 
ForEach-Object 
cmdlet is unraveled when written to the output pipe. And now let’s look at one final 
example using 
Where-Object
:
PS (130) > (gc test.txt -read 4 | %{$_} | where {$_ -like '*a*'} | 
>>> Measure-Object).count 
>>> 
10
Here you’ve inserted one more 
ForEach-Object
command between the 
gc
and the 
Where-Object
, which simply unravels the collections in 
$_ 
and so you again see a 
count of 10.
Move pdf pages in preview - 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 reverse page order in pdf; reorder pages in pdf reader
Move pdf pages in preview - 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 pages in pdf file; reorder pdf pages online
S
TATEMENTS
AS
VALUES
231
NOTE
Here’s the annoying thing: from the 
Get-Content
developer’s 
perspective, it actually is doing a read of 
-ReadCount
objects from the 
provider. 
Get-Content
reads 
-ReadCount
objects and then writes them 
as a single object to the pipeline instead of unraveling them. (I suspect 
that this is a bug that’s turned into a feature.) Anyway, the name makes 
perfect sense to the developer and absolutely no sense to the user. This 
is why developers always have to be aware of the user’s perspective even 
if it doesn’t precisely match the implementation details.
In summary, whenever 
-ReadCount
is set to a value greater than 1, usually for perfor-
mance reasons, object collections are sent through the pipeline to 
Where-Object 
instead of individual objects. As a result, you have to take extra steps to deal with 
unraveling the batched collections of objects.
At this point we’ve covered the two main flow-control cmdlets in detail. We’ve 
discussed how they work, how they can be used, and some of the benefits (and pit-
falls) you’ll encounter when using them. An important point to note is that there’s 
nothing  special  about  these  cmdlets—they  can  be  implemented  by  anyone  and 
require no special access to the inner workings of the PowerShell engine. This is a 
characteristic we’ll explore in later chapters where you’ll see how you can take advan-
tage of it. In the meantime, let’s look at one final feature of the PowerShell language: 
the ability to use all these statements we’ve been talking about as expressions that 
return  values.  Although  not  unique  to  PowerShell,  this  feature  may  seem  a  bit 
unusual to people who are used to working with languages like 
VBS
cript or 
C
#. Let’s 
take a look.
6.6
S
TATEMENTS
AS
VALUES
Let’s return to something we discussed a bit earlier when we introduced subexpres-
sions in chapter 5—namely, the difference between statements and expressions. In 
general, statements don’t return values, but if they’re used as part of a subexpression 
(or a function or script as you’ll see later on), they do return a result. This is best illus-
trated with an example. Assume that you didn’t have the range operator and wanted 
to generate an array of numbers from 1 to 10. Here’s the traditional approach you 
might use in a language such as 
C
#:
PS (1) > $result = new-object System.Collections.ArrayList 
PS (2) > for ($i=1; $i -le 10; $i++) { $result.Append($i) } 
PS (3) > "$($result.ToArray())" 
1 2 3 4 5 6 7 8 9 10
First you create an instance of 
System.Collections.ArrayList
to hold the result. 
Then you use a 
for
loop to step through the numbers, adding each number to the 
result 
ArrayList
. Finally you convert the 
ArrayList
to an array and display the 
result. This is a straightforward approach to creating the array, but requires several
How to C#: Preview Document Content Using XDoc.Word
How to C#: Preview Document Content Using XDoc.Word. Get Preview From File. You may get document preview image from an existing Word file in C#.net.
how to move pdf pages around; rearrange pdf pages in reader
How to C#: Preview Document Content Using XDoc.PowerPoint
How to C#: Preview Document Content Using XDoc.PowerPoint. Get Preview From File. You may get document preview image from an existing PowerPoint file in C#.net.
pdf reverse page order; move pdf pages in preview
232
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
steps.  Using  loops  in  subexpressions,  you can  simplify  it  quite a  bit.  Here’s the 
rewritten example:
PS (4) > $result = $(for ($i=1; $i -le 10; $i++) {$i}) 
PS (5) > "$result" 
1 2 3 4 5 6 7 8 9 10
Here you don’t have to initialize the result or do explicit adds to the result collection. 
The output of the loop is captured and automatically saved as a collection by the 
interpreter. In fact, this is more efficient than the previous example, because the inter-
preter  can  optimize  the  management  of  the  collection internally.  This  approach 
applies to any kind of statement. Let’s look at an example where you want to condi-
tionally assign a value to a variable if it doesn’t currently have a value. First verify that 
the variable has no value:
PS (1) > $var
Now do the conditional assignment. This uses an 
if
statement in a subexpression:
PS (2) > $var = $(if (! $var) { 12 } else {$var}) 
PS (3) > $var 
12
From the output, you can see that the variable has been set. Change the variable, and 
rerun the conditional assignment:
PS (4) > $var="Hello there"
PS (5) > $var = $(if (! $var) { 12 } else {$var}) 
PS (6) > $var 
Hello there
This time the variable isn’t changed.
For PowerShell version 2, the ability to assign the output of a flow-control state-
ment has been simplified so you can directly assign the output to a variable. Although 
this doesn’t add any new capabilities, it does make things simpler and cleaner. For 
instance, the previous example can be simplified to
PS (7) > $var = if (! $var) { 12 } else {$var}
using this feature. And the 
for
example you saw earlier can be simplified to
PS (4) > $result = for ($i=1; $i -le 10; $i++) {$i}
making it (somewhat) easier to read.
Used judiciously, the fact that statements can be used as value expressions can 
simplify your code in many circumstances. By eliminating temporary variables and 
extra initializations, creating collections is greatly simplified, as you saw with the 
for 
loop. On the other hand, it’s entirely possible to use this statement-as-expression 
capability to produce scripts that are hard to read. (Remember the nested 
if
state-
ment example we looked at earlier in this chapter?) You should always keep that in 
mind when using these features in scripts. The other thing to keep in mind when
C# Word - Sort Word Pages Order in C#.NET
page reorganizing library control, developers can swap or adjust the order of all or several Word document pages, or just C# DLLs: Move Word Page Position.
how to reverse pages in pdf; move pages in a pdf file
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the C# DLLs: Move PowerPoint Page Position.
pdf change page order online; how to rearrange pages in a pdf document
WORD
ABOUT
PERFORMANCE
233
you use statements is the performance of your scripts. Let’s dig into this in a bit 
more detail.
6.7
WORD
ABOUT
PERFORMANCE
Now that we’ve covered loops in PowerShell, this is a good time to talk about perfor-
mance. PowerShell is an interpreted language, which has performance implications. 
Tasks with a lot of small repetitive actions can take a long time to execute. Anything 
with a loop statement can be a performance hotspot for this reason. Identifying these 
hotspots and rewriting them can have a huge impact on script performance. Let’s take 
a look  at a real example. I was writing a script to process a collection  of events, 
extracting events having a specific name and 
ID
and placing them into a new collec-
tion. The script looked something like this:
$results = @() 
for ($i=0; $i -lt $EventList.length ; $i++) 
{
$name = [string] $Events[$i].ProviderName
$id = [long] $Events[$i].Id
if ($name -ne "My-Provider-Name") 
{
continue
}
if ($id -ne 3005) {
continue
}
$results += $Events[$i] 
}
This script indexed through the collection of events using the 
for
statement, and 
then used the 
continue
statement to skip to the next event if the current event 
didn’t match the desired criteria. If the event did match the criteria, it was appended 
to the result collection. Although this worked correctly, for large collections of events 
it was taking several minutes to execute. Let’s look at some ways to speed it up and 
make it smaller.
First, consider how you’re indexing through the collection. This requires a lot of 
index operations, variable  retrievals and  increments that  aren’t the most  efficient 
operations in  an interpreted  language  like  PowerShell.  Instead, PowerShell  has a 
number of constructs that let you iterate through a collection automatically. Given 
that the task is to select events where some condition is true, the 
Where-Object 
cmdlet is an obvious choice. The second optimization is how the result list is built. 
The original code manually adds each element to the result array. If you remember 
our discussion on how array catenation works, this means that the array has to be 
copied each time an element is added. The alternative approach, as we discussed, is to
C# PDF insert text Library: insert text into PDF content in C#.net
adding text to PDF in preview without adobe int pageIndex = 0; // Move cursor to (400F, 100F). outputFilePath = Program.RootPath + "\\" output.pdf"; doc.Save
how to reorder pages in a pdf document; reorder pdf page
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview component enables compressing and
change page order pdf acrobat; change page order pdf preview
234
CHAPTER 6
F
LOW
CONTROL
IN
SCRIPTS
simply let the pipeline do the collection for you. With these design changes, the new 
script looks like
$BranchCache3005Events = $events | where {
$_.Id -eq 3005 -and $_.ProviderName -eq "My-Provider-Name"}
The  revised  script is both hundreds  of times faster  and significantly shorter and 
clearer.
So, the rule for writing efficient PowerShell scripts is to let the system do the work 
for you. Use 
foreach
instead of explicit indexing with 
for
if you can. If you ever 
find yourself doing catenation in a loop to build up a string or collection, look at 
using the pipeline instead. You can also take advantage of the fact that all PowerShell 
statements return values so an even faster (but less obvious or simple) way to do this 
is to use the 
foreach
statement:
$BranchCache3005Events = @( foreach ($e in $events) {
if ($e.Id -eq 3005 -or
$e.ProviderName -eq "Microsoft-Windows-BranchCacheSMB") {$e}} )
The key here is still letting the system implicitly build the result array instead of con-
structing it manually with 
+=
. Likewise for string catenation, this
$s = -join $(  foreach ($i in 1..40kb) { "a" } )
is faster than
$s = "";  foreach ($i in 1..40kb) { $s += "a" } 
By following these guidelines, not only will your scripts be faster, they’ll also end up 
being shorter and frequently simpler and clearer (though not always.)
6.8
S
UMMARY
In chapter 6, we covered the branching and looping statements in the PowerShell lan-
guage as summarized in the following list:
• PowerShell allows you to use pipelines where other languages only allow expres-
sions. This means that, although the PowerShell flow-control statements appear 
to be similar to the corresponding statements in other languages, enough differ-
ences exist to make it useful for you to spend time experimenting with them.
• There are two ways of handling flow control in PowerShell. The first is to use 
the language flow-control statements such as 
while
and 
foreach
. But when 
performing pipelined operations, the alternative mechanism—the flow-control 
cmdlets 
ForEach-Object
and 
Where-Object
—can  be  more  natural  and 
efficient. 
• When  iterating  over  collections,  you  should  keep  in  mind  the  trade-offs 
between the 
foreach
statement and the 
ForEach-Object
cmdlet.
• Any statement can be used as a value expression when nested in a subexpression. 
For  example, you could use a 
while
loop in a subexpression to generate a
VB.NET PDF insert text library: insert text into PDF content in vb
Add text to PDF in preview without adobe reader Dim pageIndex As Integer = 0 ' Move cursor to (400F As String = Program.RootPath + "\\" output.pdf" doc.Save
reorder pages pdf; change page order pdf
How to C#: Preview Document Content Using XDoc.excel
How to C#: Preview Document Content Using XDoc.Excel. Get Preview From File. You may get document preview image from an existing Excel file in C#.net.
reorder pdf pages; how to move pages in pdf
S
UMMARY
235
collection of values. In PowerShell v2, for simple assignments, the subexpression 
notation is no longer needed and the output of a statement can be assigned 
directly to a variable. This mechanism can be a concise way of generating a col-
lection, but keep in mind the potential complexity that  this kind of nested 
statement can introduce.
• The PowerShell 
switch
statement is a powerful tool. On the surface it looks 
like the 
switch
statement in 
C
# or the 
select
statement in Visual Basic, but 
with powerful pattern matching capabilities, it goes well beyond what the state-
ments in the other languages can do. And, along with the pattern matching, it 
can be used as a looping construct for selecting and processing objects from a 
collection or lines read from a file. In fact, much of its behavior was adapted 
from the 
AWK
programming language.
• The choice of statements and how you use them can have a significant effect on 
the  performance  of  your  scripts.  This  is  something  to  keep  in  mind,  but 
remember, only worry about performance if it becomes a problem. Otherwise, 
try to focus on making things as clear as possible.
236
C
H
A
P T E R   7
PowerShell functions
7.1  Fundamentals of PowerShell 
functions  237
7.2  Declaring formal parameters for a 
function  241
7.3  Returning values from functions  257
7.4  Using simple functions in a pipeline 263
7.5  Managing function definitions in a 
session  267
7.6  Variable scoping in functions  269
7.7  Summary 273
Porcupine quills. We’ve always done it with porcupine quills. 
—Dilbert
In this chapter, we’ll begin looking at how to combine the features from the previous 
chapters into reusable commands. As you’ll recall from chapter 2, there are four types 
of PowerShell commands: functions, cmdlets, scripts, and external commands. Func-
tions and scripts are the two command types that can be written in the PowerShell 
language. We’ll start with functions as they’re the simpler of the two and are also easy 
to enter interactively in a session. In the next chapter we’ll expand our discussion to 
include scripts as well as introduce advanced programming features available to both 
functions and scripts. 
Before we dive in, there’s one thing you need to be aware of if you have prior pro-
gramming experience. This prior experience can be both a blessing and a curse when 
learning to program in PowerShell. Most of the time, what you already know makes 
it easier to program in PowerShell. The syntax and most of the concepts will probably 
be familiar. Unfortunately, similar isn’t identical, and this is where prior experience 
can trip you up. You’ll expect PowerShell to work like your favorite language, and it
F
UNDAMENTALS
OF
P
OWER
S
HELL
FUNCTIONS
237
won’t work quite the same way. We’ll call out these issues as we encounter them. So, 
put away your porcupine quills and let’s get started.
7.1
F
UNDAMENTALS
OF
P
OWER
S
HELL
FUNCTIONS
In this section we’ll cover the basic concepts and features of PowerShell functions. 
Functions are the most lightweight form of PowerShell command. They only exist in 
memory for the duration of a session. When you exit the shell session, the functions 
are gone. They’re also simple enough that you can create useful functions in a single 
line of code. We’ll start by working through a number of examples showing you how 
to create simple functions. Let’s take a look at our first example:
PS (1) > function hello { "Hello world" }
In this example, 
hello
is pretty obviously a function because it’s preceded by the 
function
keyword. And, equally obvious, this function should emit the string 
“Hello world.” Execute it to verify this:
PS (2) > hello; hello; hello 
Hello world 
Hello world 
Hello world
Yes, it works exactly as expected. You’ve created your first command.
Okay, that was easy. Now you know how to write a simple PowerShell function. 
The syntax is shown in figure 7.1.
But a function that writes only “Hello world” isn’t very useful. Let’s see how to 
personalize this function by allowing an argument to be passed in.
7.1.1
Passing arguments using $args
The ability to pass values into a function is called parameterizing the function. In 
most languages, this means modifying the function to declare the parameters to pro-
cess.  For simple PowerShell functions, we don’t have to do this because there’s a 
default argument array  that  contains  all  the  values  passed  to the  function.  This 
default array is available in the variable 
$args
. Here’s the previous 
hello
example 
modified to use 
$args
to receive arguments:
PS (3) > function hello { "Hello there $args, how are you?" } 
PS (4) > hello Bob 
Hello there Bob, how are you?
function <name> { <statementList> }
function keyword
List of statements that make up
function body
Braces marking beginning and
end of function body
Function name
Figure 7.1
The simplest form of 
a function definition 
in PowerShell 
238
CHAPTER 7
P
OWER
S
HELL
FUNCTIONS
This example uses string expansion to insert the value stored in 
$args
into the string 
that is emitted from the 
hello
function. Now let’s see what happens with multiple 
arguments:
PS (5) > hello Bob Alice Ted Carol 
Hello there Bob Alice Ted Carol, how are you?
Following the string expansion rules described in chapter 3,  the values stored  in 
$args 
get  interpolated  into  the  output  string  with  each  value  separated  by  a 
space—or, more specifically, separated by whatever is stored in the 
$OFS
variable. So 
let’s take one last variation on this example. We’ll set 
$OFS
in the function body with 
the aim of producing a more palatable output. You can take advantage of the interac-
tive nature of the PowerShell environment to enter this function over several lines:
PS (6) > function hello 
>> { 
>> $ofs="," 
>> "Hello there $args and how are you?" 
>> } 
>>
PS (7) > hello Bob Carol Ted Alice 
Hello there Bob,Carol,Ted,Alice and how are you?
That’s better. Now at least you have commas between the names. Let’s try it again, 
with commas between the arguments:
PS (8) > hello Bob,Carol,Ted,Alice 
Hello there System.Object[] and how are you?
This isn’t the result you were looking for! So what happened? Let’s define a new func-
tion to clear up what happened:
PS (1) > function count-args { 
>> "`$args.count=" + $args.count 
>> "`$args[0].count=" + $args[0].count 
>> } 
>>
This function will display the number of arguments passed to it as well as the number 
of elements in the first argument. First you use it with three scalar arguments:
PS (2) > count-args 1 2 3 
$args.count=3 
$args[0].count=
As expected, it shows that you passed three arguments. It doesn’t show anything for 
the 
Count
property on 
$args[0]
because 
$args[0]
is a scalar (the number 1) and 
consequently doesn’t have a 
Count
property. Now try it with a comma between each 
of the arguments:
PS (3) > Count-Args 1,2,3 
$args.count=1 
$args[0].count=3
F
UNDAMENTALS
OF
P
OWER
S
HELL
FUNCTIONS
239
Now you see that the function received one argument, which is an array of three ele-
ments. And finally, try it with two sets of comma-separated numbers:
PS (4) > count-args 1,2,3 4,5,6,7 
$args.count=2 
$args[0].count=3
The results show that the function received two arguments, both of which are arrays. 
The first argument is an array of three elements and the second is an array with four 
elements. Hmm, you  should be  saying to  yourself—this  sounds familiar. And it 
is—the comma here works like the binary comma operator in expressions, as dis-
cussed in chapter 5.
Two values on the command line with a comma between them will be passed to 
the command as a single argument. The value of that argument is an array of those 
elements. This applies to any command, not just functions. If you want to copy three 
files, f1.txt, f2.txt, and f3.txt, to a directory, the command is
copy-item f1.txt,f2.txt,f3.txt target
The 
Copy-Item
cmdlet receives two arguments: the first is an array of three file-
names, and the second is a scalar element naming the target directory. Now let’s look 
at a couple of examples where 
$args
enables simple but powerful scenarios.
7.1.2
Example functions: ql and qs
The way 
$args
works is straightforward, but it allows you to write some pretty slick 
commands. Here are two functions that aren’t in the PowerShell base installation 
(although they may be in the future, but not in either v1 or v2 … sigh):
function ql { $args } 
function qs { "$args" }
They may not look like much, but they can significantly streamline a number of 
tasks. The first function is 
ql
, which stands for quote list. This is a Perl-ism. Here’s 
what you can do with it. Say you want to build a list of the colors. To do this with the 
normal comma operator, you’d do the following,
$col = "black","brown","red","orange","yellow","green",
"blue","violet","gray","white"
which requires lots of quotes and commas. With the 
ql
function, you could write it 
this way:
$col = ql black brown red orange yellow green blue violet gray white
This  is  much  shorter  and  requires less  typing. Does  it  let you  do  anything  you 
couldn’t do before? No, but it lets you do something more efficiently when you have 
to. Remember  that  elastic  syntax  concept?  When  you’re  trying  to  fit a  complex 
expression onto one line, things like 
ql
can help. What about the other function, 
qs
?
Documents you may be interested
Documents you may be interested