c# pdf viewer itextsharp : Reorder pages in pdf online software application dll winforms windows .net web forms Windows%20Powershell%20in%20Action%202nd%20Edition6-part1516

30
CHAPTER 1
W
ELCOME
TO
P
OWER
S
HELL
>> Format-Table -AutoSize deviceid, freespace 
>> 
deviceid   freespace 
--------   ---------
C:       97778954240 
T:       31173663232 
D:         932118528
Once again, the pattern is almost identical. The 
Get-WmiObject
command returns a 
set  of  objects  from 
WMI
 You  pipe  these  objects  into 
sort
and sort on the 
freespace
property, and then use 
Select-Object
to extract the first three.
NOTE
Because of this ability to apply a command pattern over and 
over, most of the examples in this book are deliberately generic. The 
intent is to highlight the pattern of the solution rather than show a spe-
cific example. Once you understand the basic patterns, you can effec-
tively adapt them to solve a multitude of other problems. 
1.5.4
Flow-control statements
Pipelines are great, but sometimes you need more control over the flow of your script. 
PowerShell has the usual script flow-control statements found in most programming 
languages. These include the basic 
if
statements, a powerful 
switch
statement, and 
various loops like a 
while
loop, 
for
and 
foreach
loops, and so on. Here’s an exam-
ple showing use of the 
while
and 
if
statements:
PS (1) > $i=0
PS (2) > while ($i++ -lt 10) { if ($i % 2) {"$i is odd"}} 
1 is odd 
3 is odd 
5 is odd 
7 is odd 
9 is odd 
PS (3) >
This example uses the 
while
loop to count through a range of numbers, printing out 
only the odd numbers. In the body of the 
while
loop is an 
if
statement that tests to 
see whether the current number is odd, and then writes out a message if it is. You can 
do the same thing using the 
foreach
statement and the range operator (
..
), but 
much more succinctly:
PS (3) > foreach ($i in 1..10) { if ($i % 2) {"$i is odd"}} 
1 is odd 
3 is odd 
5 is odd 
7 is odd 
9 is odd
The 
foreach
statement iterates over a collection of objects, and the range operator is 
a way to generate a sequence of numbers. The two combine to make looping over a 
sequence of numbers very clean. 
Reorder pages 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 move pdf pages around; move pages in pdf document
Reorder pages 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
rearrange pages in pdf document; reorder pages in pdf online
D
UDE
! W
HERE
S
MY
CODE
?
31
Of course, because the range operator generates a sequence of numbers and num-
bers are objects like everything else in PowerShell, you can implement this using 
pipelines and the 
ForEach-Object
cmdlet:
PS (5) > 1..10 | foreach { if ($_ % 2) {"$_ is odd"}} 
1 is odd 
3 is odd 
5 is odd 
7 is odd 
9 is odd
These examples only scratch the surface of what you can do with the PowerShell 
flow-control statements (just wait until you see the 
switch
statement!). The com-
plete set of control structures is covered in detail in chapter 6 with lots of examples.
1.5.5
Scripts and functions
What good is a scripting language if you can’t package commands into scripts? Power-
Shell lets you do this by simply putting your commands into a text file with a .ps1 
extension and then running that command. You can even have parameters in your 
scripts. Put the following text into a file called hello.ps1:
param($name = "bub")
"Hello $name, how are you?"
Notice that the 
param
keyword is used to define a parameter called 
$name
. The para-
meter is given a default value of 
"bub"
. Now you can run this script from the Power-
Shell prompt by typing the name as 
.\hello
. You need the 
.\
to tell PowerShell to get 
the command from the current directory (chapter 21 explains why this is needed). 
NOTE
Before you can run scripts on a machine in the default config-
uration, you’ll have to change the PowerShell execution policy to allow 
scripts to run. See 
Get-Help –Online about_execution_policies 
for detailed instructions.
The first time you run this script, you won’t specify any arguments:
PS (1) > .\hello
Hello bub, how are you?
You see that the default value was used in the response. Run it again, but this time 
specify an argument:
PS (2) > .\hello Bruce
Hello Bruce, how are you?
Now the argument is in the output instead of the default value. Sometimes you just 
want to have subroutines in your code. PowerShell addresses this need through func-
tions. Let’s turn the hello script into a function. Here’s what it looks like:
PS (3) > function hello { 
>> param($name = "bub")
C# TIFF: How to Reorder, Rearrange & Sort TIFF Pages Using C# Code
Reorder, Rearrange and Sort TIFF Document Pages in C#.NET Application. C# TIFF Page Sorting Overview. Reorder TIFF Pages in C#.NET Application.
pdf reverse page order; rearrange pages in pdf online
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
Sort and Reorder PowerPoint Slides Range with VB amount of robust PPT slides/pages editing methods powerful & profession imaging controls, PDF document, image
rearrange pdf pages online; reorder pages in pdf reader
32
CHAPTER 1
W
ELCOME
TO
P
OWER
S
HELL
>> "Hello $name, how are you" 
>> } 
>>
The body of the function is exactly the same as the script. The only thing added is the 
function
keyword, the name of the function, and braces around the body of the 
function. Now run it, first with no arguments as you did with the script:
PS (4) > hello 
Hello bub, how are you
and then with an argument:
PS (5) > hello Bruce 
Hello Bruce, how are you
Obviously the function operates in the same way as the script except that PowerShell 
didn’t have to load it from a disk file so it’s a bit faster to call. Scripts and functions are 
covered in detail in chapter 7.
1.5.6
Remoting and the Universal Execution Model
In the previous sections, you’ve seen the kinds of things you can do with PowerShell 
on a single computer. But the computing industry has long since moved beyond a 
one-computer world. Being able to manage groups of computers, without having to 
physically visit each one, is critical in the modern 
IT
world. To address this, Power-
Shell v2 introduced built-in remote execution capabilities (remoting) and the Univer-
sal Execution Model—a fancy term that just means that if it works locally, then it 
should work remotely.
NOTE
At this point you should be asking “If this is so important why 
wasn’t it in v1?” In fact it was planned from shortly before day one of 
the PowerShell project. But, to make something universal, secure, and 
simple is, in fact, very hard. 
The core of PowerShell remoting is the 
Invoke-Command
command, which, again for 
convenience, has a much shorter alias: 
icm
. This command allows you to invoke a 
block of PowerShell script on the current computer, on a remote computer, or on a 
thousand remote computers. Let’s see some of this in action. The example scenario will 
be to check the version of the Microsoft Management Console 
(MMC)
host program 
installed on a computer. You might need to do this because you want to install an 
MMC 
extension (called a snap-in) on a set of machines and this snap-in requires a minimum 
version of the 
MMC
host. You can do this locally by using the 
Get-Command
command 
(
gcm
) to retrieve information about 
mmc.exe
, the executable for the 
MMC
host:
PS (1) > (gcm mmc.exe).FileVersionInfo.ProductVersion
6.1.7069.0
This is a simple one-line command, and it shows that version 6.1 of 
mmc.exe
is 
installed on the local machine. Now let’s run it on a remote machine. (We’ll assume
Read PDF in Web Image Viewer| Online Tutorials
"This online guide content is Out Dated! Extract images from PDF documents; Add, reorder pages in PDF files; Save and print PDF as you wish;
pdf reverse page order preview; how to move pages in pdf
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
C# PDF Page Processing: Sort PDF Pages - online C#.NET tutorial page for how to reorder, sort, reorganize or re-arrange PDF document files using C#.NET code.
how to rearrange pdf pages; move pages in pdf reader
D
UDE
! W
HERE
S
MY
CODE
?
33
that your target machine names are stored in the variables 
$m1
and 
$m2
.) Let’s check 
the version on the first machine. Run the same command as before, but this time 
enclose it in braces as an argument to 
icm
. Also give the 
icm
command the name of 
the host to execute on:
PS {2) > icm $m1 { 
>> (gcm mmc.exe).FileVersionInfo.ProductVersion 
>> } 
>>
6.0.6000.16386
Oops—this machine has an older version of 
mmc.exe
. Okay, let’s try machine 2. 
Run exactly the same command, but pass in the name of the second machine this 
time:
PS {3) > icm $m2 { 
>> (gcm mmc.exe).FileVersionInfo.ProductVersion 
>> } 
>>
6.1.7069.0
This machine is up to date. At this point you’ve addressed the need to physically go to 
each machine but you’re still executing the commands one at a time. Let’s fix that too 
by putting the machines to check into a list. You’ll use an array variable for this exam-
ple, but this list could come from a file, an Excel spreadsheet, a database, or a web ser-
vice. First, run the command with the machine list:
PS {4) > $mlist = $m1,$m2
PS {5) > icm $mlist { 
>> (gcm mmc.exe).FileVersionInfo.ProductVersion 
>> } 
>>
6.0.6000.16386
6.1.7069.0
You get same the same results as last time but as a list instead of one at a time. In prac-
tice, most of your machines are probably up to date, so you really only care about the 
ones that don’t have the correct version of the software. You can use the 
where
com-
mand to filter out the machines you don’t care about:
PS {6) > icm $mlist { 
>> (gcm mmc.exe).FileVersionInfo.ProductVersion 
>> } | where { $_ -notmatch '6\.1' } 
>>
6.0.6000.16386
This returns the list of machines that have out-of-date 
mmc.exe
versions. There’s 
still a problem, though: you see the version number but not the computer’s name. 
Obviously you’ll need this too if you’re going to update those machines. To address
VB.NET TIFF: Modify TIFF File by Adding, Deleting & Sort TIFF
Users can use it to reorder TIFF pages in ''' &ltsummary> ''' Sort TIFF document pages in designed powerful & profession imaging controls, PDF document, image
move pages in pdf; how to reverse pages in pdf
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
Online C# class source codes enable the ability to rotate single NET, add new PDF page, delete certain PDF page, reorder existing PDF pages and split
reorder pdf pages in preview; reorder pdf pages reader
34
CHAPTER 1
W
ELCOME
TO
P
OWER
S
HELL
this, PowerShell remoting automatically adds the name of the originating computer 
to each received object using a special property called 
PSComputerName
Now let’s jump ahead a bit and see how much effort it’d be to produce a nice 
table of computer names and version  numbers. You’ll run the remote command 
again, use 
where
to filter the results, extract the fields you want to display using the 
select
command, and finally format the report using the 
Format-Table
command. 
For the purpose of this example, you’ll add the machine lists together so you know 
you’ll get two records in your report. Here’s what the command looks like: 
PS {7) > icm ($mlist + $mlist) { 
>>           (gcm mmc.exe).FileVersionInfo.ProductVersion } | 
>>       where { $_ -notmatch '6\.1' } | 
>>       select @{n="Computer"; e={$_.PSComputerName}}, 
>>              @{n="MMC Version"; e={$_}} | 
>>       Format-Table -auto 
>>
Computer      MMC Version 
--------      -----------
brucepaydev07 6.0.6000.16386 
brucepaydev07 6.0.6000.16386
Although the command may look a bit scary, you were able to produce your report 
with little effort. And the techniques you used for formatting the report can be used 
over and over again. This example shows how easily PowerShell remoting can be used 
to expand the reach of your scripts to cover one, hundreds, or thousands of comput-
ers all at once. But sometimes you just want to work with a single remote machine 
interactively. Let’s see how to do that.
The 
Invoke-Command
command is the way to programmatically execute Power-
Shell commands on a remote machine. When you want to connect to a machine so 
you can interact with it on a one-to-one basis, you use the 
Enter-PSSession
com-
mand. This command allows you to start an interactive one-to-one session with a 
remote computer. Running 
Enter-PSSession
looks like this:
PS (11) > Enter-PSSession server01
[server01]: PS > (gcm mmc.exe).FileVersionInfo.ProductVersion
6.0.6000.16386 
[brucepaydev07]: PS > Get-Date
Sunday, May 03, 2009 7:40:08 PM
[server01]: PS > exit
PS (12) >
As shown here, when you connect to the remote computer, your prompt changes to 
indicate that you’re working remotely. Otherwise, once connected, you can pretty 
much interact  with  the remote computer  the  same way  you  would with  a  local 
machine. When you’re done, exit the remote session with the 
exit
command, and
C# Word: How to Create Word Document Viewer in C#.NET Imaging
Offer mature Word file page manipulation functions (add, delete & reorder pages) in document viewer; (Directly see online document viewer demo here.).
pdf reorder pages online; reorder pdf page
VB.NET TIFF: VB.NET Sample Code to Process & Manage TIFF Page
certain TIFF page, and sort & reorder TIFF pages in Process TIFF Pages Independently in VB.NET Code. powerful & profession imaging controls, PDF document, image
reorder pages in pdf file; how to change page order in pdf acrobat
S
UMMARY
35
this pops you back to the local session. This brief introduction covers some powerful 
techniques, but we’ve only begun to cover all the things remoting lets you do.
At this point, we’ll end our “Cook’s tour” of PowerShell. We’ve only breezed over 
the features and capabilities of the environment. There are many other areas of Pow-
erShell that we haven’t covered here, especially in v2, which introduced advanced 
functions  and  scripts,  modules,  eventing  support,  and  many  more  features.  In 
upcoming chapters, we’ll explore each of the elements discussed here in detail and a 
whole lot more.
1.6
S
UMMARY
This chapter covered what PowerShell is and, just as important, why it is. We also 
took a whirlwind tour through some simple examples of using PowerShell interac-
tively. Here are the key points that we covered:
• PowerShell is the new command-line/scripting environment from Microsoft. 
Since  its  introduction  with  Windows  Server  2008,  PowerShell  has  rapidly 
moved to the center of Microsoft server and application management technolo-
gies. Many of the most important server products, including Exchange, Active 
Directory, and 
SQL S
erver, now use PowerShell as their management layer.
• The Microsoft Windows management model is primarily object based, through 
.
NET
COM
, and 
WMI
. This required Microsoft to take a novel approach to 
command-line scripting, incorporating object-oriented concepts into a com-
mand-line shell. PowerShell uses the .
NET
object model as the base for its type 
system but can also access other object types like 
WMI
.
• PowerShell is an interactive environment with two different host applications: 
the console host 
PowerShell.exe
and the graphical host 
powershell_ 
ise.exe
. It can also be “hosted” in other applications to act as the scripting 
engine for those applications.
• Shell operations like navigation and file manipulation in PowerShell are similar 
to what you’re used to in other shells.
• The way to get help about things in PowerShell is to use the 
Get-Help
com-
mand (or by selecting text and pressing 
F
1 in the 
ISE
).
• PowerShell is sophisticated with a full range of calculation, scripting, and text 
processing capabilities. 
• PowerShell v2 introduced a comprehensive set of remoting features to allow you 
to do scripted automation of large collections of computers.
In the following chapters, we’ll look at each of the PowerShell features we showed you 
here in much more detail. Stay tuned!
36
C
H
A
P T E R   2
Foundations of PowerShell
2.1  Getting a sense of the 
PowerShell language  37
2.2  The core concepts  38
2.3  Aliases and elastic syntax  46
2.4  Parsing and PowerShell  50
2.5  How the pipeline works  60
2.6  Formatting and output  64
2.7  Summary  70
“Begin at the beginning,” the king said 
“and then go on till you come to the end, then stop.” 
—Lewis Carroll, Alice in Wonderland
Vizzini: Inconceivable! 
Inigo: You keep on using that word. I do not think it means what 
you think it means.
—William Goldman, The Princess Bride
This chapter introduces the foundational concepts underlying the PowerShell lan-
guage and its environment. We’ll cover language details that are specific to PowerShell 
and look at how the interpreter parses the commands we type. This chapter also cov-
ers the various types of commands you’ll encounter along with the anatomy and 
operation of the pipeline itself. We’ll look at the basic syntax for expressions and com-
mands, including how to add comments to scripts and how arguments and parame-
ters  are  handled.  Finally,  we’ll  close  the  chapter  with  a  discussion  of  how  the 
formatting and output subsystem works in PowerShell. 
G
ETTING
A
SENSE
OF
THE
P
OWER
S
HELL
LANGUAGE
37
The  chapter presents  many  examples that aren’t  completely  explained.  If you 
don’t understand everything when you read the examples, don’t worry—we’ll revisit 
the material in later chapters. In this chapter, we just want to cover the core con-
cepts—we’ll focus on the details in subsequent chapters.
2.1
G
ETTING
A
SENSE
OF
THE
P
OWER
S
HELL
LANGUAGE
Before digging too deep into PowerShell concepts and terminology, let’s capture some 
first impressions of the language: what does the PowerShell language look and feel 
like? Birdwatchers have  to  learn  how  to  distinguish  hundreds  of  species  of  fast-
moving little brown birds (or 
LBB
s, as they’re known). To understand how they do 
this, I consulted with my wife, the “Master Birder.” (The only bird I can identify is a 
chicken, preferably stuffed and roasted.) Birdwatchers use something called the 
GISS 
principle, which stands for General Impression, Size, and Shape. It’s that set of char-
acteristics that allow us to determine what we’ve seen even though we’ve had only a 
very brief or distant glance. Take a look at the silhouettes shown in figure 2.1. The 
figure shows the relative sizes of four birds and highlights the characteristic shape of 
each one. This is more than enough information to recognize each bird.
What does this have to do with computers (other than to prove we aren’t the only 
ones who make up strange acronyms)? In essence, the 
GISS
principle also works well 
with programming languages. The 
GISS
of the PowerShell syntax is that it’s like any 
of the 
C
programming language descendents with specific differences such as the fact 
that variables are distinguished by a leading dollar (
$
) sign.
NOTE
PowerShell uses the at symbol (
@
) in a few places, has 
$_
as a 
default variable, and uses 
&
as the function call operator. These ele-
ments lead people to say that PowerShell looks like Perl. In practice, at 
one point, we did use Perl as a root language, and these elements stem
Figure 2.1 This figure illustrates the GISS principle—the general impression, size, and 
shape of some common birds. Even without any detail, the basic shape and size is enough 
for most people to identify these birds. This same principle can be applied when learning 
programming languages; a sense of the overall shape of the language allows you to iden-
tify common coding patterns in the language.
38
CHAPTER 2
F
OUNDATIONS
OF
P
OWER
S
HELL
from that period. Later on, the syntax was changed to align more with 
C#, but we kept these elements because they worked well. In Perl ter-
minology,  they  contributed  significantly  to  the  “whipupitude  quo-
tient” of the language. In fact, the language that PowerShell looks most 
like  is 
PHP
 (This  wasn’t  deliberate.  It’s  a  case  of  parallel  evolu-
tion—great minds thinking alike, and all that.) But don’t let this fool 
you; semantically, PowerShell and 
PHP
are quite different.
2.2
T
HE
CORE
CONCEPTS
The core PowerShell language is based on the 
IEEE
standard 
POSIX
1003.2 grammar 
for the Korn shell. This standard was chosen because of its maturity and long history 
as a successful basis for modern shells like bash and zsh. The language design team 
(Jim Truher and I) deviated from this standard where necessary to address the specific 
needs of an object-based shell. We also deviated in areas where we wanted to make it 
easier to write sophisticated scripts. Originally, Perl idioms were appropriated for 
some of the advanced scripting concepts such as arrays and hash tables. As the project 
progressed, it became clear that aligning PowerShell syntax with 
C
# was more appro-
priate. If nothing else, this would facilitate migrating code between PowerShell and 
C
#. The major value this brings is that PowerShell code can be migrated to 
C
# when 
necessary for performance improvements, and 
C
# examples can be easily converted to 
PowerShell. This second point is important—the more examples you have in a new 
language, the better off you are.
2.2.1
Command concepts and terminology
As with any piece of new technology, PowerShell has its own terminology, although 
we’ve tried to stick to existing terms as much as we could. Consequently, much of the 
terminology used in PowerShell will be familiar if you’ve used other shells in the 
Linux or Windows world. But because PowerShell is a new kind of shell, there are a 
number of terms that are different and a few new terms to learn. In this section, we’ll 
go over the PowerShell-specific concepts and terminology for command types and 
command syntax.
2.2.2
Commands and cmdlets
Commands are the fundamental part of any shell language; they’re what you type to 
get things done. As you saw in the previous chapter, a simple command looks like 
this:
command –parameter1 –parameter2 argument1 argument2
A more detailed illustration of the anatomy of this command is shown in figure 2.2. 
This figure calls out all the individual elements of the command.
T
HE
CORE
CONCEPTS
39
All commands are broken down into the command name, the parameters specified to 
the command, and the arguments to those parameters.
NOTE
The distinction between parameter and argument may seem a 
bit strange from a programmer’s perspective. But if you’re used to lan-
guages such as Python and Visual Basic that allow for keyword param-
eters,  PowerShell  parameters  correspond  to  the  keywords,  and 
arguments correspond to the values. 
The first element in the command is the name of the command to be executed. The 
PowerShell interpreter looks at this name and determines what has to be done. It 
must figure out not only which command to run but which kind of command to run. 
In PowerShell, there are four categories of commands: cmdlets, shell function com-
mands, script commands, and native Windows commands. (We’ll cover the different 
categories in detail in the following sections.) Following the command name come 
zero or more parameters and/or arguments. A parameter starts with a dash, followed 
by the name of the parameter. An argument, on the other hand, is the value that will 
be associated with, or bound to, a specific parameter. Let’s look at an example:
PS (1) > Write-Output -InputObject Hello 
Hello
In this example, the command is 
Write-Output
, the parameter is 
-InputObject
and the argument is 
Hello
What about the positional parameters mentioned in figure 2.1? When a Power-
Shell command is created, the author of that command specifies information that 
allows PowerShell to determine which parameter to bind an argument to, even if the 
parameter name itself is missing. For example,  the 
Write-Output
command has 
been defined so that the first parameter is 
-InputObject
. This lets you write
PS (2) > Write-Output Hello 
Hello
instead of having to specify 
-InputObject
. The piece of the PowerShell interpreter 
that figures all of this out is called the parameter binder. The parameter binder is
command  -parameter1 -parameter2 arg1 arg2
Command
name
Parameter with
argument
Switch parameter
Positional
argument
Figure 2.2 The anatomy of a basic 
command. It begins with the name of 
the command, followed by some num-
ber of parameters. These may be switch 
parameters that take no arguments, 
regular parameters that do take argu-
ments, or positional parameters, where 
the matching parameter is inferred by the 
argument’s position on the command line.
Documents you may be interested
Documents you may be interested