80
CHAPTER 3
W
ORKING
WITH
TYPES
The result shows the output of the three statements concatenated together, space sep-
arated, and inserted into the result string. Here’s another example of using a 
for 
statement in a subexpression expansion:
PS (1) > "Numbers 1 thru 10: $(for ($i=1; $i -le 10; $i++) { $i })." 
Numbers 1 thru 10: 1 2 3 4 5 6 7 8 9 10.
PS (2) >
The output of all the iterations for the loop are gathered up, turned into a string with 
one value separated from the next by a space, and then substituted into the overall 
string. As you can see, this can be quite powerful. Using a subexpression in a string is 
one way to quickly generate formatted results when presenting data.
String expansion considerations
PowerShell  expands  strings  when  an  assignment is executed. It  doesn’t reevaluate 
those strings when the variable is used later. This is an important point. Let’s look at 
two examples that will make this clear. These examples use the postincrement opera-
tor 
++
 which  adds 1 to a  variable, and  the  range operator,  which  expands to a 
sequence of numbers. 
In the first example, initialize 
$x
to 0 and then assign a string with an expansion 
that increments 
$x
to a variable 
$a
. Next output 
$a
three times to see what happens 
to the value of 
$x
:
PS (1) > $x=0
PS (2) > $a = "x is $($x++; $x)" 
PS (4) > 1..3 | foreach {$a} 
x is 1 
x is 1 
x is 1
As you can see, 
$x
was incremented once when 
$a
was assigned but didn’t change on 
subsequent references. Now inline the string literal into the body of the loop and see 
what happens:
PS (5) > 1..3 | foreach {"x is $($x++; $x)"} 
x is 1 
x is 2 
x is 3
This time around, you can see that 
$x
is being incremented each time. To reiterate, 
string literal expansion is done only when the literal is assigned.
NOTE
There’s a way to force a string to be expanded if you need to 
do it. You can do this by calling 
$ExecutionContext.InvokeCom-
mand.ExpandString( 'a is $a' )
. This method will return a new 
string with all the variables expanded. 
Here-string literals
Getting back to the discussion of literal string notation, there’s one more form of 
string literal, called a here-string. A here-string is used to embed large chunks of text
Pdf change page order 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 reorder pages in pdf; reorder pages in pdf online
Pdf change page order 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
pdf reverse page order; how to reorder pages in pdf file
B
ASIC
TYPES
AND
LITERALS
81
inline in a script. This can be powerful when you’re generating output for another 
program. Here’s an example that assigns a here-string to the variable 
$a
:
PS (1) > $a = @" 
>> Line one 
>> Line two 
>> Line three 
>> "@ 
>>
PS (2) > $a 
Line one 
Line two 
Line three
NOTE
Here’s a note for 
C
# users. There’s a lexical element in 
C
# that 
looks a lot like PowerShell here-strings. In practice, the 
C
# feature is 
most  like PowerShell’s  single-quoted strings. In  PowerShell, a here-
string begins at the end of the line and the terminating sequence must 
be at the beginning of the line that terminates the here-string. In 
C
#, 
the string terminates at the first closing quote that isn’t doubled up.
When 
$a
is displayed, it contains all the lines that were entered. Now you’re probably 
saying, “Wait a minute—you told me I can do the same thing with a regular string. 
What makes here-strings so special?” It has to do with how quoting is handled. Here-
strings have special quoting rules.
Here-strings start with 
@<quote><newline>
and end with 
<newline><quote>@
The 
<newlines>
are important because the here-string quote sequences won’t be 
treated as quotes without them. The content of the here-string is all the lines between 
the beginning and ending quotes but not the lines the quotes are on. Because of the 
fancy opening and closing quote sequences, other special characters (such as quotes 
that would cause problems in regular strings) are fine here. This makes it easy to gen-
erate string data without having quoting errors. Here’s a more elaborate example:
PS (1) > $a = @" 
>> One is "1" 
>> Two is '2' 
>> Three is $(2+1) 
>> The date is "$(get-date)" 
>> "@ + "A trailing line" 
>>
PS (2) > $a 
One is "1"
Two is '2'
Three is 3 
The date is "1/8/2006 9:59:16 PM"A trailing line 
PS (3) >
On line 1, the here-string is assigned to the variable 
$a
. The contents of the here-
string start on line 2, which has a string containing double quotes. Line 3 has a string 
with single quotes. Line 4 has an embedded expression, and line 5 calls the 
Get-Date
VB.NET Word: Change Word Page Order & Sort Word Document Pages
Note: if you are trying to change the order controls, please read this Word reading page which has powerful & profession imaging controls, PDF document, image
rearrange pages in pdf document; rearrange pdf pages in reader
C# Word - Process Word Document in C#
For example, you may change your Word document order from 1, 2, 3, 4, 5 to 3, 5, 4, 2,1 with C# coding. C#.NET: Extracting Page(s) from Word.
move pages in a pdf file; rearrange pdf pages reader
82
CHAPTER 3
W
ORKING
WITH
TYPES
cmdlet in a subexpression to embed the current date into the string. Finally, line 6 
appends some trailing text to the whole string. When you look at the output of the 
variable shown in lines 9–12, you see that the quotes are all preserved and the expan-
sions are shown in place.
Here-strings come in single and double-quoted versions just like regular strings, 
with  the  significant  difference  being  that  variables  and  subexpressions  aren’t 
expanded in the single-quoted variant, as shown here:
PS (1) > $a=123 
PS (2) > @" 
>> a is $a 
>> "@ 
>> 
a is 123
In the double-quoted  here-string, the variable 
$a
is expanded, but in the single-
quoted here-string
PS (3) > @' 
>> a is $a 
>> '@ 
>> 
a is $a 
PS (4) >
it isn’t. The single-quoted version is best for embedding large blocks of literal text 
where you don’t want to have to deal with individually quoting 
$
everywhere. You’ll 
see how useful this can be when we look at the 
Add-Type
cmdlet in chapter 9.
That should be enough about strings for now. Let’s move on to numbers and 
numeric literals. This will finally let us express that “10 
MB
” value we wanted to 
compare against earlier.
3.2.2
Numbers and numeric literals
As mentioned earlier, PowerShell supports all the basic .
NET
numeric types and per-
forms conversions to and from the different types as needed. Table 3.2 lists these 
numeric types.
Table 3.2 Numeric literals
Example numeric literal
.NET full type name
Short type name
0x1FE4
System.Int32
[int]
10000000000 
10l
System.Int64
[long]
1.1 
1e3
System.Double
[double]
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Convert Jpeg to PDF; Merge PDF Files; Split PDF Document; Remove Password from PDF; Change PDF Permission Settings. C# File: Split PDF; C# Page: Insert PDF pages
change page order in pdf reader; reorder pages in pdf
C# PowerPoint - Sort PowerPoint Pages Order in C#.NET
control, developers can swap or adjust the order of all or several PowerPoint document pages, or just change the position of certain one PowerPoint page in an
reorder pages in pdf preview; how to move pages in pdf converter professional
B
ASIC
TYPES
AND
LITERALS
83
Now that you know the basic numeric types, you need to understand how literals of 
each type are specified.
Specifying numeric literals
In general, you don’t specify a literal having a particular type; the system will figure 
out the best way to represent the number. By default, an integer will be used. If the 
literal is too large for a 32-bit integer, a 64-bit integer will be used instead. If it’s still 
too  big or  if  it  contains  a decimal  point,  a 
System.Double
will be used. (The 
System.Single
single-precision floating point isn’t used for numeric literals because 
it offers no advantages and just complicates the process.) The one case where you do 
want  to tell the system that you’re requesting a specific  type is  with the 
System 
.Decimal
type. These are specified by placing the letter d at the end of the number 
with no intervening space, as shown:
PS (1) > ( 123 ).gettype().fullname 
System.Int32 
PS (2) > ( 123d ).gettype().fullname 
System.Decimal 
PS (3) > ( 123.456 ).gettype().fullname 
System.Double 
PS (4) > ( 123.456d ).gettype().fullname 
System.Decimal
You can see that in each case where there’s a trailing d, the literal results in a 
[deci-
mal]
value being created. (If there’s a space between the number and the d, you’ll get 
an error.)
The multiplier suffixes
Plain numbers are fine for most applications, but in the system administration world, 
there are many special values that you want to be able to conveniently represent, 
namely, those powers of two—kilobytes, megabytes, gigabytes, terabytes, and peta-
bytes (terabyte and petabyte suffixes aren’t available in PowerShell v1).
PowerShell provides a set of multiplier suffixes for common sizes to help with this, 
as listed in table 3.3. These suffixes allow you to easily express common very large 
numbers.
There is no single-precision 
numeric literal but you can use 
a cast: 
[float] 1.3
System.Single
[single] or 
[float]
1d
1.123d
System.Decimal
[decimal]
Table 3.2 Numeric literals (continued)
Example numeric literal
.NET full type name
Short type name
C# Word - Sort Word Pages Order in C#.NET
library control, developers can swap or adjust the order of all or several Word document pages, or just change the position of certain one Word page in an
rearrange pdf pages online; move pages in pdf reader
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
page from PDF file and changing the position, orientation and order of PDF file into two or small files, you may refer to this online guide. PDF Page inserting.
rearrange pages in pdf online; pdf change page order acrobat
84
CHAPTER 3
W
ORKING
WITH
TYPES
NOTE
Yes, the PowerShell team is aware that these notations aren’t 
consistent with the 
ISO/IEC
recommendations (kilobyte, and so on). 
Because the point of this notation is convenience and most 
IT
people 
are more comfortable with 
KB
than with Ki, we choose to err on the 
side of comfort over conformance in this one case. This particular issue 
generated  easily  the  second-most  heated  debate  on  the  PowerShell 
internal  and  external  beta  tester  lists.  We’ll  cover  the most  heated 
debate later when we get to the comparison operators.
Hexadecimal literals
The last item we’ll cover in this section is hexadecimal literals. When working with 
computers, it’s obviously useful to be able to specify hex literals. PowerShell uses the 
same notation as 
C
C
#, and so on—preceding the number with the sequence 0x and 
allowing the letters A–F as the extra digits. As always, the notation is case insensitive, 
as shown in the following examples:
PS (1) > 0x10 
16 
PS (2) > 0x55 
85 
PS (3) > 0x123456789abcdef 
81985529216486895 
PS (4) > 0xDeadBeef 
-559038737
Table 3.3 The numeric multiplier suffixes supported in PowerShell. Suffixes marked v2 are
only available in version 2 or PowerShell.
Multiplier 
suffix
Multiplication factor
Example
Equivalent value
.NET type
kb or KB
1024
1 KB
1024
System.Int32
kb or KB
1024
2.2 KB
2252.8
System.Double
mb or MB
1024*1024
1 MB
1048576
System.Int32
mb or MB
1024*1024
2.2 MB
2306867.2
System.Double
gb or GB
1024*1024*1024
1 GB
1073741824
System.Int32
gb or GB
1024*1024*1024
2.14 GB
2297807503.36
System.Double
tb or TB 
(v2 only)
1024*1024*1024* 
1024
1 TB
1099511627776
System.Int64
tb or TB 
(v2 only)
1024*1024*1024* 
1024
2.14 TB
2352954883440.64
System.Double
pb or PB 
(v2 only)
1024*1024*1024* 
1024*1024
1 PB
1125899906842624
System.Int64
pb or PB 
(v2 only)
1024*1024*1024* 
1024*1024
2.14 PB
2.40942580064322E+15
System.Int64
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via password by using Change PDF original password. VB.NET: Necessary DLLs for PDF Password Edit.
pdf rearrange pages; reverse page order pdf online
C# PDF Password Library: add, remove, edit PDF file password in C#
Able to change password on adobe PDF document in C# in C# project, XDoc.PDF provides some PDF security settings. On this page, we will talk about how to achieve
rearrange pdf pages; pdf reverse page order preview
C
OLLECTIONS
DICTIONARIES
AND
HASHTABLES
85
Now that we’ve covered the “basic” literals, strings, and numbers, let’s move on to the 
more interesting and less common ones. This is one of the areas where the power of 
scripting languages shines. These literals let you express complex configuration data, 
inline in your script, in a clear and direct fashion. This, in turn, means that you don’t 
have to use an external data language like 
XML
or 
INI
files to encode this configura-
tion data. PowerShell lets you express this information in PowerShell itself.
3.3
C
OLLECTIONS
DICTIONARIES
AND
HASHTABLES
Perhaps the most flexible data type in PowerShell is the hashtable. This data type lets 
you map a set of keys to a set of values. For example, we may have a hashtable that 
maps “red” to 1, “green” to 2, and “yellow” to 4. 
NOTE
A dictionary is the general term for a data structure that maps 
keys to values. In the .
NET
world, this takes the form of an interface 
(
System.Collections.IDictionary
 that  describes  how  a  collec-
tion should do this mapping. A hashtable is a specific implementation 
of that interface. Although the PowerShell hashtable literal syntax only 
creates  instances  of 
System.Collections.Hashtable
 scripts  that 
you  write  will  work  properly  with  any  object  that  implements 
IDictionary
3.3.1
Creating and inspecting hashtables
In PowerShell, you use hash literals to create a hashtable inline in a script. Here’s a 
simple example:
PS (26) > $user = @{ FirstName = "John"; LastName = "Smith"; 
>> PhoneNumber = "555-1212" }
PS (27) > $user
Key                            Value 
---                            -----
LastName                       Smith 
FirstName                      John 
PhoneNumber                    555-1212
This example created a hashtable that contains three key-value pairs. The hashtable 
starts with the token 
@{
and ends with 
}
. Inside the delimiters, you define a set of 
key-value pairs where the key and value are separated by an equals sign (
=
). Formally, 
the syntax for a hash literal is
<hashLiteral> = '@{' <keyExpression> '='  <pipeline> [ <separator> 
<keyExpression> '=' <pipeline> ] * '}'
Now that you’ve created a hashtable, let’s see how you can use it. PowerShell allows 
you to access members in a hashtable in two ways—through property notation and 
through array notation. Here’s what the property notation looks like:
PS (3) > $user.firstname 
John
86
CHAPTER 3
W
ORKING
WITH
TYPES
PS (4) > $user.lastname 
Smith
This notation lets you treat a hashtable like an object. This access method is intended 
to facilitate the use of hashtables as a kind of lightweight data record. Now let’s look 
at using the array notation:
PS (5) > $user["firstname"]
John 
PS (6) > $user["firstname","lastname"] 
John 
Smith
Property notation works pretty much the way you’d expect; you specify a property 
name and get the corresponding value back. Array notation, on the other hand, is 
more interesting. In the second command in the example, you provided two keys and 
got two values back. 
Here’s  an  example  that  shows  some  additional  features  of  the  underlying 
hashtable object. The underlying object for PowerShell hashtables is the .
NET
type 
System.Collections.Hashtable
. This type has a number of properties and meth-
ods that you can use. One of these properties is 
keys
. This property will give you a 
list of all the keys in the hashtable:
PS (7) > $user.keys 
LastName 
FirstName 
PhoneNumber
In the array access notation, you can use 
keys
to get a list of all the values in the 
table:
PS (8) > $user[$user.keys] 
Smith 
John 
555-1212
NOTE
A more efficient way to get all of the values from a hashtable is 
to use the 
Values
property. The point of this example is to demon-
strate how you can use multiple indexes to retrieve the values based on 
a subset of the keys.
You might have noticed that the 
keys
property didn’t return the keys in alphabetical 
order. This is because of the way hashtables work—keys are randomly distributed in 
the table to speed up access. If you do need to get the values in alphabetical order, 
here’s how you can do it:
PS (10) > $user.keys | sort-object 
FirstName 
LastName 
PhoneNumber
C
OLLECTIONS
DICTIONARIES
AND
HASHTABLES
87
The 
Sort-Object
(or just 
sort
) cmdlet sorts the keys into alphabetical order and 
returns a list. Use this list to index the table:
PS (11) > $user[[string[]] ($user.keys | sort)] 
John 
Smith 
555-1212
You’ll notice something funny about the last example: we had to cast or convert the 
sorted list into an array of strings. This is because the hashtable keys mechanism 
expects strings, not objects, as keys. There’s much more on casts later in this chapter.
A digression: sorting, enumerating, and hashtables
Let’s digress for a second and address a question that comes up sometimes when peo-
ple,  especially .
NET
programmers, first  encounter  hashtables  in  PowerShell. The 
question is, “Are hashtables collections or scalar objects?” From the .
NET
perspective, 
they’re enumerable collections just like arrays except they contain a collection of key-
value pairs. However, and this is important, PowerShell treats hashtables like scalar 
objects. It does this because, in scripting languages, hashtables are commonly used as 
on-the-fly structures or data records. Using hashtables this way, you don’t have to pre-
define the fields in a record; you just make them up as you go. If PowerShell treated 
hashtables as enumerable collections by default, this wouldn’t be possible because 
every time you passed one of these “records” into a pipeline, it would be broken up 
into a stream of individual key-value pairs  and the  integrity of the original table 
would be lost. 
This  causes  the  most  problems  for  people  when  they  use  hashtables  in  the 
foreach
statement. In a .
NET
language like 
C
#, the 
foreach
statement iterates over 
all  the  pairs.  In  PowerShell,  the 
foreach
loop will run only once because the 
hashtable isn’t considered an enumerable, at least not by default. So, if you do want 
to iterate over the pairs, you’ll have to call the 
GetEnumerator()
method yourself. 
This looks like
PS (12) >  $h = @{a=1; b=2; c=3}
PS (13) >  foreach ($pair in $h.GetEnumerator()) 
>>  { 
>>     $pair.key + " is " + $pair.value 
>>  } 
>> 
a is 1 
b is 2 
c is 3
In each iteration, the next pair is assigned to 
$pair
and processing continues. 
A significant part of the reason this behavior confuses people is that when Power-
Shell displays a hashtable, it uses enumeration to list the key-value pairs as part of the 
presentation. The result is that there’s no visible difference between when you call
88
CHAPTER 3
W
ORKING
WITH
TYPES
GetEnumerator()
in the 
foreach
loop and when you don’t. Let’s look at this. First, 
the no 
GetEnumerator()
case:
PS (14) >  foreach ($pair in $h) { $pair }
Name                           Value 
----                           -----
                             1 
                             2 
                             3
Now call 
GetEnumerator()
in the loop:
PS (15) >  foreach ($pair in $h.GetEnumerator()) { $pair }
Name                           Value 
----                           -----
                             1 
                             2 
                             3
As you can see, the output is identical in both cases. This is desirable in the sense that 
it’s a good way to present a hashtable and doesn’t require effort from the user to do 
this. On the other hand, it masks the details of what’s really going on. As always, it’s 
difficult to serve all audiences perfectly.
Another aspect of the hashtable collection question is that people want to be able 
to “sort” a hashtable the way you’d sort a list of numbers. In the case of a hashtable, 
this usually means that the user wants to be able to control the order in which keys 
will  be  retrieved  from  the  hashtable.  Unfortunately  this  can’t  work  because  the 
default hashtable object that PowerShell uses has no way to store any particular key 
ordering in the table. The keys are just stored in random order, as you saw earlier in 
this section. If you want to have an ordered dictionary, you’ll have to use a different 
type of object, such as
[Collections.Generic.SortedDictionary[object,object]]
This is a sorted generic dictionary (we’ll get to type literals and generics later in this 
chapter). And now, back to our regularly scheduled topic.
3.3.2
Modifying and manipulating hashtables
Next let’s look at adding, changing, and removing elements in the hashtable. First let’s 
add the date and the city where the user lives to the 
$user
table.
PS (1) > $user.date = get-date 
PS (2) > $user 
Key                            Value 
---                            -----
LastName                       Smith 
date                           1/15/2006 12:01:10 PM 
FirstName                      John 
PhoneNumber                    555-1212
C
OLLECTIONS
DICTIONARIES
AND
HASHTABLES
89
PS (3) > $user["city"] = "Seattle"
PS (4) > $user 
Key                            Value 
---                            -----
city                           Seattle 
LastName                       Smith 
date                           1/15/2006 12:01:10 PM 
FirstName                      John 
PhoneNumber                    555-1212
A simple assignment using either the property or array accessor notation allows you 
to add an element to a hashtable. Now let’s say you got the city wrong—John really 
lives in Detroit. Let’s fix that:
PS (5) > $user.city = "Detroit"
PS (6) > $user 
Key                            Value 
---                            -----
city                           Detroit 
LastName                       Smith 
date                           1/15/2006 12:01:10 PM 
FirstName                      John 
PhoneNumber                    555-1212
As this example shows, simple assignment is the way to update an element. Finally, 
you don’t want this element, so remove it from the table with the 
remove()
method:
PS (7) > $user.remove("city")
PS (8) > $user 
Key                            Value 
---                            -----
LastName                       Smith 
date                           1/15/2006 12:01:10 PM 
FirstName                      John 
PhoneNumber                    555-1212 
The hashtable no longer contains the element.
If you want to create an empty hashtable, use 
@{ }
with no member specifications 
between the braces. This creates an empty table that you can then add members to 
incrementally:
PS (1) > $newHashTable = @{}
PS (2) > $newHashTable 
PS (3) > $newHashTable.one =1 
PS (4) > $newHashTable.two = 2 
PS (5) > $newHashTable
Key                            Value 
---                            -----
two                            2 
one                            1
In the example, there were no members initially; you added two by making assign-
ments. The members are created on assignment.
Documents you may be interested
Documents you may be interested