c# pdf viewer free : How to reorder pages in pdf preview SDK application API wpf html winforms sharepoint Windows%20Powershell%20in%20Action%202nd%20Edition20-part1473

170
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
you get the elements that correspond to the original index value—2 returns 2, and so 
on. But do you need to use the intermediate variable? Let’s try it:
PS (7) > $a[2,3,4,5 | foreach {$_-1}] 
Missing ']' after array index expression. 
At line:1 char:12 
+ $a[2,3,4,5 | <<<<  foreach {$_-1}]
So you get a parsing error. This doesn’t mean that you can’t do it. It just means that 
you have to wrap the expression in brackets so it will be treated as a single value:
PS (8) > $a[(2,3,4,5 | foreach {$_-1})] 
PS (9) >
This time there was no error, and you get the values you expected. 
5.4.4
Using the range operator with arrays
There’s one other tool in the indexing toolkit: the range operator discussed in the pre-
vious section. This operator is a convenient way to get slices of arrays. Say you have 
an array of 10 elements, 0 through 9. To get the first four elements of an array, you 
can use the range operator as follows:
PS (2) > $a[0..3] 
3
By taking advantage of the way negative indexing works, you can get the last four ele-
ments of the array by doing this:
PS (3) > $a[-4..-1] 
9
You can even use ranges to reverse an array. To do this, you need to know the length 
of the array, which you can get through the 
length
property. You can see this in the 
following example, which casts the result of the expression to a string so it will be dis-
played on one line:
PS (6) > [string] $a[ ($a.Length-1) .. 0] 
9 8 7 6 5 4 3 2 1 0
NOTE
This isn’t an efficient way of reversing the array. Using the 
Reverse
static member on the 
[array]
class is more efficient. See 
section 5.4.4 for more information on how to use .
NET
methods in 
PowerShell.
How to reorder pages in pdf preview - 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 in pdf reader; how to move pages in a pdf file
How to reorder pages in pdf 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
how to change page order in pdf document; pdf change page order online
A
RRAY
OPERATORS
171
In PowerShell, slicing works for retrieving elements of an array, but you can’t use it for 
assignments. You get an error if you try. For example, try to replace the slice 
[2,3,4] 
with a single value 12:
PS (1) > $a = 1,2,3,4,5,6,7,8 
PS (2) > $a[2,3,4] = 12 
Array assignment to [2,3,4] failed because assignment to slices is 
not supported.
At line:1 char:4 
+ $a[2 <<<< ,3,4] = 12
As you can see, you get an error telling you that assignment to slices isn’t supported. 
Here’s what you have to do to get the desired transformation:
PS (3) > $a = $a[0,1] + 12 + $a[5 .. 7] 
PS (4) > $a 
12 
8
Basically, you have to take the array slices before and after the desired values and then 
concatenate all three pieces together to produce a new array.
5.4.5
Working with multidimensional arrays
So far we’ve covered one-dimensional arrays as well as arrays of arrays (which are also 
called jagged arrays). The reason for the term “jagged” is shown in figure 5.10. 
In figure 5.10, 
$a
is an array of arrays as you’ve seen before, but each of the mem-
ber arrays is a different length. So instead of having a regular structure, you have a 
jagged one because the counts are uneven.
0
1
2
0
1
2
3
0
1
2
3
4
0
1
0
$a[0]
$a[0][2] -eq 2
$a[1][4] -eq 4
$a[3][3] -eq 3
$a[4][0] -eq 0
$a[5][1] -eq 1
$a[1]
$a[2]
$a[3]
$a[4]
$a[5]
"Hello"
"world"
$a[2]13] -eq "world"
Figure 5.10 An example of a jagged array in the variable 
$a
. Each member of 
$a
is also an array but they are all of different lengths—hence the term “jagged.”
C# Word: How to Create Word Document Viewer in C#.NET Imaging
thumbnail preview for accurate Word page navigation and location in C#.NET; Offer mature Word file page manipulation functions (add, delete & reorder pages) in
move pages within pdf; how to move pages in pdf acrobat
VB.NET Image: Web Image and Document Viewer Creation & Design
can rotate, redact & annotate images and add, delete & reorder document pages with zero It is a powerful toolkit to print bitonal images, PDF, and so
pdf rearrange pages online; rearrange pdf pages online
172
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
Now that you understand what a jagged array is, we’ll move on to multidimensional 
arrays. PowerShell needs to support multidimensional arrays because .
NET
allows for 
arrays to be multidimensional and PowerShell is built on top of .
NET
. Figure 5.11 
shows a two-dimensional array.
As shown in figure 5.11,  PowerShell indexes into multidimensional  arrays  by 
looking at the type of the array and mapping the set of indexes onto the number of 
dimensions or rank the array has. If you specify two indexes and the array is one-
dimensional, you’ll get two elements back. If the array is two-dimensional, you’ll get 
one element back. Let’s try this. 
First, construct a multidimensional array using the 
New-Object
cmdlet:
PS (1) > $2d = new-object 'object[,]' 2,2
This statement created a 2 x 2 array of objects. Look at the dimensions of the array by 
retrieving the 
Rank
property from the object:
PS {2) > $2d.Rank 
2
Now set the value in the array to particular values. Do this by indexing into the array:
PS (3) > $2d[0,0] = "a"
PS (4) > $2d[1,0] = 'b' 
PS (5) > $2d[0,1] = 'c' 
PS (6) > $2d[1,1] = 'd' 
PS (7) > $2d[1,1] 
d
This appears to imply that slices don’t work in multidimensional arrays, but in fact 
they do when you use nested arrays of indexes and wrap the expression by using the 
comma operator in parentheses:
PS (8) > $2d[ (0,0) , (1,0) ] 
b
This example retrieved the elements of the array at indexes (0,0) and (1,0). And, as in 
the case of one-dimensional arrays, you can use variables for indexing:
PS (9) > $one=0,0 ; $two=1,0 
PS (10) > $2d [ $one, $two ]
Unexpected token ' $one, $two ' in expression or statement. 
At line:1 char:18 
+ $2d [ $one, $two ] <<<<
$a[0, 0] -eq 0
$a[5, 0]  -eq 5
$a[0, 3] -eq 18 
$a[5, 3] -eq 23
$a = new-object 'object[,]' 6,4
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Figure5.11 A two-dimensional 
6 x 4 array of numbers
P
ROPERTY
AND
METHOD
OPERATORS
173
PS (11) > $2d[ $one, $two ] 
b
And you can even use a variable containing a pair of index arrays:
PS (12) > $pair = $one,$two 
PS (13) > $2d[ $pair ] 
b
This covers pretty much everything we need to say about arrays. Now let’s move on to 
properties and methods. As you’ll remember from chapter 1, properties and methods 
are the attributes of an object that let you inspect and manipulate that object. Because 
PowerShell is an object-based  shell, a good understanding of  how properties and 
methods  work  is  necessary if you  want  to  master  PowerShell.  We’re going to be 
spending a fair bit of time on these features, so let’s get started.
5.5
P
ROPERTY
AND
METHOD
OPERATORS
As you’ve seen in many examples so far, the property dereference operator in Power-
Shell is the dot (
.
). As was the case with array indexing, this is properly considered an 
operator in PowerShell with left and right operand expressions. This operator, along 
with the static member operator 
::
, is shown in figure 5.12.
We’ll get to what that means in a second. 
NOTE
When we say property here, we’re talking about any kind of 
data member on an object, regardless of the underlying Common Lan-
guage Runtime representation (or implementation) of the member. If 
you don’t know what this means, good—because it doesn’t matter. But 
some people do like to know all the details of what’s going on.
First let’s look back at the basics. Everything in PowerShell is an object (even scripts 
and functions, as you’ll see later on). As discussed in chapter 1, objects have proper-
ties (data) and methods (code). To get at both, you use the dot operator. To get the 
length of a string, you use the 
length
property:
PS (1) > "Hello world!".Length 
12
<typeValue>::<memberNameExpr>
<typeValue>::<memberNameExpr>(<arguments>)
<value>.<memberNameExpr>
<value>.<memberNameExpr>(<arguments>)
Property and method reference operators
Figure 5.12 The property and method operators in PowerShell
174
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
In a similar fashion, you can get the length of an array:
PS (3) > (1,2,3,4,5).Length 
5
As was the case with the left square bracket in array indexing, spaces aren’t permitted 
between the left operand and the dot:
PS (4) > (1,2,3,4,5) .count 
Unexpected token '.count' in expression or statement. 
At line:1 char:18 
+ (1,2,3,4,5) .count <<<<
This is necessary to make sure that arguments to cmdlets aren’t mistaken for property 
reference operations:
PS (5) > write-output (1,2,3,4,5) .count 
.count
5.5.1
The dot operator
So much for the basics—now let’s get back to this statement about the dot being an 
operator. What’s special about it? Well, just as the left operand can be an expression, 
so can the right operand. The right operand is evaluated, which results in a value. 
That value is then used as the name of the property on the left operand to retrieve. 
This series of steps is illustrated in figure 5.13.
Initial expression
5
("*" * 5) . length
("*" * 5) . ("len" + "gth")
"*****" . length
Evaluates right-hand side
to get property name
Evaluates left-hand side
to get object from which 
to retrieve property
Evaluates . to retrieve
value of property
Figure 5.13 The steps performed to retrieve a calculated property from an object
P
ROPERTY
AND
METHOD
OPERATORS
175
Let’s look at an example of how this process can be used with variables. First define a 
variable to hold the name of the property you want to retrieve:
PS (6) > $prop = "length"
Now, use that variable in an expression to retrieve the property:
PS (7) > "Hello world".$prop 
11
This mechanism gives you that magic “one more level of indirection” computer sci-
ence people are so fond of. Let’s expand on this. To get a list of all the properties on 
an object, use the 
Get-Member
(or 
gm
) cmdlet on an object. This example uses 
dir
to 
get a 
FileInfo
object to work with:
PS (1) > @(dir c:\windows\*.dll)[0] | gm -type property
TypeName: System.IO.FileInfo
Name              MemberType Definition 
----              ---------- ----------
Attributes        Property   System.IO.FileAttributes Attributes ... 
CreationTime      Property   System.DateTime CreationTime {get;s ... 
CreationTimeUtc   Property   System.DateTime CreationTimeUtc {ge ... 
Directory         Property   System.IO.DirectoryInfo Directory   ... 
DirectoryName     Property   System.String DirectoryName {get;} 
Exists            Property   System.Boolean Exists {get;}
Extension         Property   System.String Extension {get;}
FullName          Property   System.String FullName {get;} 
IsReadOnly        Property   System.Boolean IsReadOnly {get;set;} 
LastAccessTime    Property   System.DateTime LastAccessTime {get;s ... 
LastAccessTimeUtc Property   System.DateTime LastAccessTimeUtc {ge ... 
LastWriteTime     Property   System.DateTime LastWriteTime {get;se ... 
LastWriteTimeUtc  Property   System.DateTime LastWriteTimeUtc {get ... 
Length            Property   System.Int64 Length {get;}
Name              Property   System.String Name {get;}
This gives you a list of all the properties. Of course, you only need the name, so you 
can use the 
Name
property on these objects:
PS (2) > @(dir c:\windows\*.dll)[0] | gm -type property | 
>>> foreach {$_.name}
Attributes 
CreationTime 
CreationTimeUtc 
Directory 
DirectoryName 
Exists 
Extension 
FullName 
IsReadOnly 
LastAccessTime 
LastAccessTimeUtc 
LastWriteTime
176
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
LastWriteTimeUtc 
Length 
Name
Next you’ll use this list of names to get the corresponding values from the original 
object. First get the object into a variable:
PS (1) > $obj = @(dir c:\windows\*.dll)[0]
And get the list of names; for brevity’s sake, just get the properties that start with the 
letter l:
PS (2) > $names = $obj | gm -type property l* | foreach {$_.name}
Finally, use the list of names to print out the value:
PS (3) > $names | foreach { "$_ = $($obj.$_)" } 
LastAccessTime = 3/25/2006 2:18:50 AM 
LastAccessTimeUtc = 3/25/2006 10:18:50 AM 
LastWriteTime = 8/10/2004 12:00:00 PM 
LastWriteTimeUtc = 8/10/2004 7:00:00 PM 
Length = 94784 
PS (4) >
Next let’s look at using methods. The method call syntax is
<valueExpression> . <methodName> ( <argument> , <argument> , ... )
As always, spaces aren’t allowed before or after the dot or before the opening paren-
thesis for the reasons discussed earlier. Here’s a basic example:
PS (1) > "Hello world!".substring(0,5)
Hello
This example uses the 
Substring
method to extract the first five characters from the 
left operand string. As you can see, the syntax for method invocations in PowerShell 
matches what you see in pretty much every other language that has methods. Con-
trast this with how commands are called. In method calls, arguments in the argument 
list are separated by commas and the whole list is enclosed in parentheses. With com-
mands, the arguments are separated with spaces and the command ends at the end of 
line or at a command terminator, such as the semicolon or the pipe symbol. 
This is another area where the language design team experimented with alternate 
syntaxes. One of the experiments we conducted resulted in a command-like method 
invocation syntax that looked something like
"Hello world!".(substring 0 5)
The team chose not to use this syntax for two reasons (which, by the way, means that 
you’ll get an error if you try using it). First, it collided with the ability to perform indi-
rect property name retrievals. The second (and more important) reason was that people 
also found it uncomfortably strange. Empirically, a programmer-style syntax for pro-
grammer-style activities like method invocations and a shell-style syntax for shell-style
P
ROPERTY
AND
METHOD
OPERATORS
177
activities like command invocation seems to work best. This approach is not without 
some small issues. First, if you want to pass an expression to a method, you have to wrap 
that array in parentheses so the array comma operator isn’t confused with the argument 
separator commas. Second, if you want to use the output of a command as an argu-
ment, you have to wrap the command in parentheses. Here’s an example:
PS (1) > [string]::join('+',(1,2,3)) 
1+2+3
This example uses the 
[string]::Join 
method to create a string out of the array 
1,2,3
with a plus sign between each one. Now let’s do the same thing with the out-
put of a command. Here’s a command that returns the handle count for the 
rundll 
processes:
PS (1) > get-process rundll* | foreach{$_.handles} 
58 
109
Now join that output into a string, again separated with the plus sign (with spaces on 
either side this time):
PS (2) > [string]::join(" + ", (get-process rundll* | 
>>> foreach{$_.handles})) 
58 + 109
The observant reader will have noticed the use of the double-colon operator (::) in 
these examples. We briefly discussed this operator in chapter 3 as part of our discus-
sion of types in PowerShell. In the next section, we’ll look at it in more detail.
5.5.2
Static methods and the double-colon operator
The 
::
operator is the static member accessor. Whereas the dot operator retrieved 
instance members, the double-colon operator accesses static members on a class, as is 
the case with the 
join
method in the example at the end of the last section. The left 
operand to the static member accessor is required to be a type—either a type literal or 
an expression returning a type as you see here:
PS (1) > $t = [string]
PS (2) > $t::join('+',(1,2,3)) 
1+2+3 
PS (3) >
The language design team chose to use a separate operator for accessing static meth-
ods because of the way static methods are accessed. Here’s the problem. If you had a 
type 
MyModule
with a static property called 
Module
, then the expression
[MyModule].Module
is ambiguous. This is because there’s also an instance member 
Module
on the 
System 
.Type
instance representing the type 
MyModule
. Now you can’t tell if the “Module”
178
CHAPTER 5
A
DVANCED
OPERATORS
AND
VARIABLES
instance member on 
System.Type
or the “Module” static member on 
MyModule 
should be retrieved. By using the double-colon operator, you remove this ambiguity.
NOTE
Other  languages  get  around  this  ambiguity  by  using  the 
typeof()
operator. Using 
typeof()
in this example, 
typeof(My 
Module).Module
retrieves the instance property on the 
Type
object 
and 
MyModule.Module
retrieves the static property implemented by 
the 
MyModule
class.
5.5.3
Indirect method invocation
Earlier we talked about how you could do indirect property references by using a vari-
able on the right side of the dot operator. You can do the same thing with methods, 
but it’s a bit more complicated. The obvious approach
$x.$y(2)
doesn’t  work.  What  happens  is  that 
$x.$y
returns an object that describes the 
method you want to invoke:
PS {1) > "abc".substring
MemberType          : Method
OverloadDefinitions : {string Substring(int startIndex), st
ring Substring(int startIndex, int le
ngth)}
TypeNameOfValue     : System.Management.Automation.PSMethod 
Value               : string Substring(int startIndex), str
ing Substring(int startIndex, int len
gth)
Name                : Substring 
IsInstance          : True
This turns out to be a handy way to get information about a method. Let’s pick out the 
overloads for 
Substring
—that is, the different forms of this method that you can use:
PS {2) > "abc".substring | foreach { 
>> $_.OverloadDefinitions -split '\),' } 
>> 
string Substring(int startIndex) 
string Substring(int startIndex, int length) 
PS {3) >
Now you have this information object—what else can you do with it? The thing you 
most probably want to do is to invoke it. The way to do this is to use the 
Invoke 
method on the method information object:
PS {3) > "abc".substring.Invoke(1) 
bc
In version 2 of PowerShell, this also works for static methods. First assign the name of 
the operation to invoke to a variable:
PS {4) > $method = "sin"
T
HE
FORMAT
OPERATOR
179
Look at the information about that method:
PS {5) > [math]::$method
MemberType          : Method
OverloadDefinitions : {static double Sin(double a)} 
TypeNameOfValue     : System.Management.Automation.PSMethod 
Value               : static double Sin(double a)
Name                : Sin 
IsInstance          : True
And, finally, invoke it:
PS {6) > [math]::$method.invoke(3.14)
0.00159265291648683
Although it’s an advanced technique, the ability to invoke properties and methods 
indirectly turns out to be powerful because it means that the behavior of your script 
can be configured at runtime. You’ll learn how this can be used when we talk about 
scriptblocks in chapter 8.
This finishes our discussion of properties and methods. You may have noticed 
that in some of the examples so far, you’ve had to do some fairly complicated things 
to display the results in the way you want. Clearly, on occasion you’ll need a better 
way to present output, and that’s the purpose of the format operator, covered in the 
next section.
5.6
T
HE
FORMAT
OPERATOR
Most of the time, PowerShell’s 
built-in formatting and output 
system will take care of present-
ing  your  results,  but  some-
times  you  need  more  explicit 
control  over  the formatting of 
your  output.  You  may  also 
want to format text strings in a specific way, like displaying numbers in hexadecimal 
format. PowerShell allows you to do these things with the format operator, shown in 
figure 5.14.
The format operator 
(-f)
is a binary operator that takes a format string as its left 
operand and an array of values to format as its right operand. Here’s an example:
PS (1) > '{2} {1} {0}' -f 1,2,3 
3 2 1
In the format string, the values enclosed in braces correspond to the index of the ele-
ment in the right operand array. The element is converted into a string and then dis-
played. Along with reordering, when the elements are displayed, you can control how 
they’re laid out. 
<formatSpecificationString> -f <argumentList>
Format operator
Figure 5.14 The format operator lets you control the 
formatting of your output.
Documents you may be interested
Documents you may be interested